| From 6d2ef4c8ba2304ee4941a6719b3ad9bd63e415a9 Mon Sep 17 00:00:00 2001 |
| From: Martin Jansa <martin.jansa@gmail.com> |
| Date: Wed, 18 Oct 2023 21:09:44 +0200 |
| Subject: [PATCH] Revert io_uring changes from libuv-1.45.0 |
| |
| This reverts https://github.com/libuv/libuv/pull/3952/commits/26c79a942b92573a1388c0ee8a6ad4397f009318 |
| |
| Included in nodejs-20.3.0 with the libuv upgrade to 1.45.0 in: |
| https://github.com/nodejs/node/commit/bfcb3d1d9a876f399013d326bd65804f9eda77e4 |
| |
| Reverted libuv commits: |
| Revert "linux: fix WRITEV with lots of bufs using io_uring (#4004)" |
| This reverts commit ef6a9a624df0a00687037474025a3608472f722a. |
| Revert "linux: work around EOWNERDEAD io_uring kernel bug (#4002)" |
| This reverts commit d23a20f62cc50b9fd7694992263f1d296d8f5cb4. |
| Revert "unix: handle CQ overflow in iou ring (#3991)" |
| This reverts commit 30fc896cc1b5822e9f1eb462587fe4b368a6215c. |
| Revert "unix: constrained_memory should return UINT64_MAX (#3753)" |
| This reverts commit 6ad347fae4520f39520d34bd7c7f5ddafab13a69. |
| Revert "linux: use io_uring to batch epoll_ctl calls (#3979)" |
| This reverts commit 6e073ef5daf93b708a654008959b823b58029e88. |
| Revert "linux: fix logic bug in sqe ring space check (#3980)" |
| This reverts commit f27208224084fc972b9d2802486d97ef31b51a39. |
| Revert "src: fix events/events_waiting metrics counter (#3957)" |
| This reverts commit e02642cf3b768b2c58a41f97fa38507e032ae415. |
| Revert "linux: remove bug workaround for obsolete kernels (#3965)" |
| This reverts commit 1c935a34454167b23f8eef7f0f63d7119f0de747. |
| Revert "linux: add IORING_OP_CLOSE support (#3964)" |
| This reverts commit dfae365f844e127621128a76bce7165e3f99a8d9. |
| Revert "linux: add IORING_OP_OPENAT support (#3963)" |
| This reverts commit 5ca5e475bb1711e65323ef1594a31818e5a1a9eb. |
| Revert "linux: fix academic valgrind warning (#3960)" |
| This reverts commit a7ff759ca1deacb2e0e6ae3c2d3dce91cc637dfe. |
| Revert "linux: introduce io_uring support (#3952)" |
| This reverts commit d2c31f429b87b476a7f1344d145dad4752a406d4. |
| |
| 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/docs/src/fs.rst | 6 - |
| deps/uv/docs/src/misc.rst | 5 +- |
| deps/uv/src/threadpool.c | 21 - |
| deps/uv/src/unix/aix.c | 11 +- |
| deps/uv/src/unix/fs.c | 57 +- |
| deps/uv/src/unix/internal.h | 23 - |
| deps/uv/src/unix/kqueue.c | 10 +- |
| deps/uv/src/unix/linux.c | 998 +++----------------------- |
| deps/uv/src/unix/os390.c | 11 +- |
| deps/uv/src/unix/posix-poll.c | 11 +- |
| deps/uv/src/uv-common.h | 28 - |
| deps/uv/src/win/core.c | 20 +- |
| deps/uv/test/test-fs.c | 33 - |
| deps/uv/test/test-list.h | 4 - |
| deps/uv/test/test-metrics.c | 151 ---- |
| deps/uv/test/test-threadpool-cancel.c | 34 +- |
| 16 files changed, 138 insertions(+), 1285 deletions(-) |
| |
| diff --git a/deps/uv/src/threadpool.c b/deps/uv/src/threadpool.c |
| index 51962bf0021..a3da53026f9 100644 |
| --- a/deps/uv/src/threadpool.c |
| +++ b/deps/uv/src/threadpool.c |
| @@ -275,13 +275,9 @@ void uv__work_submit(uv_loop_t* loop, |
| } |
| |
| |
| -/* TODO(bnoordhuis) teach libuv how to cancel file operations |
| - * that go through io_uring instead of the thread pool. |
| - */ |
| static int uv__work_cancel(uv_loop_t* loop, uv_req_t* req, struct uv__work* w) { |
| int cancelled; |
| |
| - uv_once(&once, init_once); /* Ensure |mutex| is initialized. */ |
| uv_mutex_lock(&mutex); |
| uv_mutex_lock(&w->loop->wq_mutex); |
| |
| @@ -311,15 +307,12 @@ void uv__work_done(uv_async_t* handle) { |
| QUEUE* q; |
| QUEUE wq; |
| int err; |
| - int nevents; |
| |
| loop = container_of(handle, uv_loop_t, wq_async); |
| uv_mutex_lock(&loop->wq_mutex); |
| QUEUE_MOVE(&loop->wq, &wq); |
| uv_mutex_unlock(&loop->wq_mutex); |
| |
| - nevents = 0; |
| - |
| while (!QUEUE_EMPTY(&wq)) { |
| q = QUEUE_HEAD(&wq); |
| QUEUE_REMOVE(q); |
| @@ -327,20 +320,6 @@ void uv__work_done(uv_async_t* handle) { |
| w = container_of(q, struct uv__work, wq); |
| err = (w->work == uv__cancelled) ? UV_ECANCELED : 0; |
| w->done(w, err); |
| - nevents++; |
| - } |
| - |
| - /* This check accomplishes 2 things: |
| - * 1. Even if the queue was empty, the call to uv__work_done() should count |
| - * as an event. Which will have been added by the event loop when |
| - * calling this callback. |
| - * 2. Prevents accidental wrap around in case nevents == 0 events == 0. |
| - */ |
| - if (nevents > 1) { |
| - /* Subtract 1 to counter the call to uv__work_done(). */ |
| - uv__metrics_inc_events(loop, nevents - 1); |
| - if (uv__get_internal_fields(loop)->current_timeout == 0) |
| - uv__metrics_inc_events_waiting(loop, nevents - 1); |
| } |
| } |
| |
| diff --git a/deps/uv/src/unix/aix.c b/deps/uv/src/unix/aix.c |
| index f1afbed49ec..b855282ebc8 100644 |
| --- a/deps/uv/src/unix/aix.c |
| +++ b/deps/uv/src/unix/aix.c |
| @@ -131,7 +131,6 @@ int uv__io_check_fd(uv_loop_t* loop, int fd) { |
| |
| |
| void uv__io_poll(uv_loop_t* loop, int timeout) { |
| - uv__loop_internal_fields_t* lfields; |
| struct pollfd events[1024]; |
| struct pollfd pqry; |
| struct pollfd* pe; |
| @@ -155,8 +154,6 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| return; |
| } |
| |
| - lfields = uv__get_internal_fields(loop); |
| - |
| while (!QUEUE_EMPTY(&loop->watcher_queue)) { |
| q = QUEUE_HEAD(&loop->watcher_queue); |
| QUEUE_REMOVE(q); |
| @@ -220,7 +217,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| base = loop->time; |
| count = 48; /* Benchmarks suggest this gives the best throughput. */ |
| |
| - if (lfields->flags & UV_METRICS_IDLE_TIME) { |
| + if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) { |
| reset_timeout = 1; |
| user_timeout = timeout; |
| timeout = 0; |
| @@ -235,12 +232,6 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| if (timeout != 0) |
| uv__metrics_set_provider_entry_time(loop); |
| |
| - /* Store the current timeout in a location that's globally accessible so |
| - * other locations like uv__work_done() can determine whether the queue |
| - * of events in the callback were waiting when poll was called. |
| - */ |
| - lfields->current_timeout = timeout; |
| - |
| nfds = pollset_poll(loop->backend_fd, |
| events, |
| ARRAY_SIZE(events), |
| diff --git a/deps/uv/src/unix/fs.c b/deps/uv/src/unix/fs.c |
| index 00d385c24b7..c696a8d5500 100644 |
| --- a/deps/uv/src/unix/fs.c |
| +++ b/deps/uv/src/unix/fs.c |
| @@ -61,11 +61,10 @@ |
| #endif |
| |
| #if defined(__linux__) |
| -# include <sys/sendfile.h> |
| -# include <sys/utsname.h> |
| +# include "sys/utsname.h" |
| #endif |
| |
| -#if defined(__sun) |
| +#if defined(__linux__) || defined(__sun) |
| # include <sys/sendfile.h> |
| # include <sys/sysmacros.h> |
| #endif |
| @@ -1554,7 +1553,26 @@ static int uv__fs_statx(int fd, |
| return UV_ENOSYS; |
| } |
| |
| - uv__statx_to_stat(&statxbuf, buf); |
| + buf->st_dev = makedev(statxbuf.stx_dev_major, statxbuf.stx_dev_minor); |
| + buf->st_mode = statxbuf.stx_mode; |
| + buf->st_nlink = statxbuf.stx_nlink; |
| + buf->st_uid = statxbuf.stx_uid; |
| + buf->st_gid = statxbuf.stx_gid; |
| + buf->st_rdev = makedev(statxbuf.stx_rdev_major, statxbuf.stx_rdev_minor); |
| + buf->st_ino = statxbuf.stx_ino; |
| + buf->st_size = statxbuf.stx_size; |
| + buf->st_blksize = statxbuf.stx_blksize; |
| + buf->st_blocks = statxbuf.stx_blocks; |
| + buf->st_atim.tv_sec = statxbuf.stx_atime.tv_sec; |
| + buf->st_atim.tv_nsec = statxbuf.stx_atime.tv_nsec; |
| + buf->st_mtim.tv_sec = statxbuf.stx_mtime.tv_sec; |
| + buf->st_mtim.tv_nsec = statxbuf.stx_mtime.tv_nsec; |
| + buf->st_ctim.tv_sec = statxbuf.stx_ctime.tv_sec; |
| + buf->st_ctim.tv_nsec = statxbuf.stx_ctime.tv_nsec; |
| + buf->st_birthtim.tv_sec = statxbuf.stx_btime.tv_sec; |
| + buf->st_birthtim.tv_nsec = statxbuf.stx_btime.tv_nsec; |
| + buf->st_flags = 0; |
| + buf->st_gen = 0; |
| |
| return 0; |
| #else |
| @@ -1798,9 +1816,6 @@ int uv_fs_chown(uv_loop_t* loop, |
| int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { |
| INIT(CLOSE); |
| req->file = file; |
| - if (cb != NULL) |
| - if (uv__iou_fs_close(loop, req)) |
| - return 0; |
| POST; |
| } |
| |
| @@ -1848,9 +1863,6 @@ int uv_fs_lchown(uv_loop_t* loop, |
| int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { |
| INIT(FDATASYNC); |
| req->file = file; |
| - if (cb != NULL) |
| - if (uv__iou_fs_fsync_or_fdatasync(loop, req, /* IORING_FSYNC_DATASYNC */ 1)) |
| - return 0; |
| POST; |
| } |
| |
| @@ -1858,9 +1870,6 @@ int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { |
| int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { |
| INIT(FSTAT); |
| req->file = file; |
| - if (cb != NULL) |
| - if (uv__iou_fs_statx(loop, req, /* is_fstat */ 1, /* is_lstat */ 0)) |
| - return 0; |
| POST; |
| } |
| |
| @@ -1868,9 +1877,6 @@ int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { |
| int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { |
| INIT(FSYNC); |
| req->file = file; |
| - if (cb != NULL) |
| - if (uv__iou_fs_fsync_or_fdatasync(loop, req, /* no flags */ 0)) |
| - return 0; |
| POST; |
| } |
| |
| @@ -1917,9 +1923,6 @@ int uv_fs_lutime(uv_loop_t* loop, |
| int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { |
| INIT(LSTAT); |
| PATH; |
| - if (cb != NULL) |
| - if (uv__iou_fs_statx(loop, req, /* is_fstat */ 0, /* is_lstat */ 1)) |
| - return 0; |
| POST; |
| } |
| |
| @@ -1981,9 +1984,6 @@ int uv_fs_open(uv_loop_t* loop, |
| PATH; |
| req->flags = flags; |
| req->mode = mode; |
| - if (cb != NULL) |
| - if (uv__iou_fs_open(loop, req)) |
| - return 0; |
| POST; |
| } |
| |
| @@ -2012,11 +2012,6 @@ int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, |
| memcpy(req->bufs, bufs, nbufs * sizeof(*bufs)); |
| |
| req->off = off; |
| - |
| - if (cb != NULL) |
| - if (uv__iou_fs_read_or_write(loop, req, /* is_read */ 1)) |
| - return 0; |
| - |
| POST; |
| } |
| |
| @@ -2124,9 +2119,6 @@ int uv_fs_sendfile(uv_loop_t* loop, |
| int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { |
| INIT(STAT); |
| PATH; |
| - if (cb != NULL) |
| - if (uv__iou_fs_statx(loop, req, /* is_fstat */ 0, /* is_lstat */ 0)) |
| - return 0; |
| POST; |
| } |
| |
| @@ -2190,11 +2182,6 @@ int uv_fs_write(uv_loop_t* loop, |
| memcpy(req->bufs, bufs, nbufs * sizeof(*bufs)); |
| |
| req->off = off; |
| - |
| - if (cb != NULL) |
| - if (uv__iou_fs_read_or_write(loop, req, /* is_read */ 0)) |
| - return 0; |
| - |
| POST; |
| } |
| |
| diff --git a/deps/uv/src/unix/internal.h b/deps/uv/src/unix/internal.h |
| index 6c5822e6a0d..d439ae6dd3d 100644 |
| --- a/deps/uv/src/unix/internal.h |
| +++ b/deps/uv/src/unix/internal.h |
| @@ -329,28 +329,6 @@ int uv__random_getentropy(void* buf, size_t buflen); |
| int uv__random_readpath(const char* path, void* buf, size_t buflen); |
| int uv__random_sysctl(void* buf, size_t buflen); |
| |
| -/* io_uring */ |
| -#ifdef __linux__ |
| -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_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_statx(uv_loop_t* loop, |
| - uv_fs_t* req, |
| - int is_fstat, |
| - int is_lstat); |
| -#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_open(loop, req) 0 |
| -#define uv__iou_fs_read_or_write(loop, req, is_read) 0 |
| -#define uv__iou_fs_statx(loop, req, is_fstat, is_lstat) 0 |
| -#endif |
| - |
| #if defined(__APPLE__) |
| int uv___stream_fd(const uv_stream_t* handle); |
| #define uv__stream_fd(handle) (uv___stream_fd((const uv_stream_t*) (handle))) |
| @@ -427,7 +405,6 @@ int uv__statx(int dirfd, |
| int flags, |
| unsigned int mask, |
| 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); |
| #endif |
| |
| diff --git a/deps/uv/src/unix/kqueue.c b/deps/uv/src/unix/kqueue.c |
| index 82916d65933..deb486bae7a 100644 |
| --- a/deps/uv/src/unix/kqueue.c |
| +++ b/deps/uv/src/unix/kqueue.c |
| @@ -127,7 +127,6 @@ static void uv__kqueue_delete(int kqfd, const struct kevent *ev) { |
| |
| |
| void uv__io_poll(uv_loop_t* loop, int timeout) { |
| - uv__loop_internal_fields_t* lfields; |
| struct kevent events[1024]; |
| struct kevent* ev; |
| struct timespec spec; |
| @@ -156,7 +155,6 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| return; |
| } |
| |
| - lfields = uv__get_internal_fields(loop); |
| nevents = 0; |
| |
| while (!QUEUE_EMPTY(&loop->watcher_queue)) { |
| @@ -224,7 +222,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| base = loop->time; |
| count = 48; /* Benchmarks suggest this gives the best throughput. */ |
| |
| - if (lfields->flags & UV_METRICS_IDLE_TIME) { |
| + if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) { |
| reset_timeout = 1; |
| user_timeout = timeout; |
| timeout = 0; |
| @@ -247,12 +245,6 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| if (pset != NULL) |
| pthread_sigmask(SIG_BLOCK, pset, NULL); |
| |
| - /* Store the current timeout in a location that's globally accessible so |
| - * other locations like uv__work_done() can determine whether the queue |
| - * of events in the callback were waiting when poll was called. |
| - */ |
| - lfields->current_timeout = timeout; |
| - |
| nfds = kevent(loop->backend_fd, |
| events, |
| nevents, |
| diff --git a/deps/uv/src/unix/linux.c b/deps/uv/src/unix/linux.c |
| index 5f84ad0eea3..343e37f2527 100644 |
| --- a/deps/uv/src/unix/linux.c |
| +++ b/deps/uv/src/unix/linux.c |
| @@ -27,8 +27,6 @@ |
| #include "internal.h" |
| |
| #include <inttypes.h> |
| -#include <stdatomic.h> |
| -#include <stddef.h> /* offsetof */ |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| @@ -40,29 +38,15 @@ |
| #include <net/if.h> |
| #include <sys/epoll.h> |
| #include <sys/inotify.h> |
| -#include <sys/mman.h> |
| #include <sys/param.h> |
| #include <sys/prctl.h> |
| #include <sys/stat.h> |
| #include <sys/syscall.h> |
| #include <sys/sysinfo.h> |
| -#include <sys/sysmacros.h> |
| #include <sys/types.h> |
| #include <time.h> |
| #include <unistd.h> |
| |
| -#ifndef __NR_io_uring_setup |
| -# define __NR_io_uring_setup 425 |
| -#endif |
| - |
| -#ifndef __NR_io_uring_enter |
| -# define __NR_io_uring_enter 426 |
| -#endif |
| - |
| -#ifndef __NR_io_uring_register |
| -# define __NR_io_uring_register 427 |
| -#endif |
| - |
| #ifndef __NR_copy_file_range |
| # if defined(__x86_64__) |
| # define __NR_copy_file_range 326 |
| @@ -132,129 +116,6 @@ |
| # include <netpacket/packet.h> |
| #endif /* HAVE_IFADDRS_H */ |
| |
| -enum { |
| - UV__IORING_SETUP_SQPOLL = 2u, |
| -}; |
| - |
| -enum { |
| - UV__IORING_FEAT_SINGLE_MMAP = 1u, |
| - UV__IORING_FEAT_NODROP = 2u, |
| - UV__IORING_FEAT_RSRC_TAGS = 1024u, /* linux v5.13 */ |
| -}; |
| - |
| -enum { |
| - UV__IORING_OP_READV = 1, |
| - UV__IORING_OP_WRITEV = 2, |
| - UV__IORING_OP_FSYNC = 3, |
| - UV__IORING_OP_OPENAT = 18, |
| - UV__IORING_OP_CLOSE = 19, |
| - UV__IORING_OP_STATX = 21, |
| - UV__IORING_OP_EPOLL_CTL = 29, |
| -}; |
| - |
| -enum { |
| - UV__IORING_ENTER_GETEVENTS = 1u, |
| - UV__IORING_ENTER_SQ_WAKEUP = 2u, |
| -}; |
| - |
| -enum { |
| - UV__IORING_SQ_NEED_WAKEUP = 1u, |
| - UV__IORING_SQ_CQ_OVERFLOW = 2u, |
| -}; |
| - |
| -struct uv__io_cqring_offsets { |
| - uint32_t head; |
| - uint32_t tail; |
| - uint32_t ring_mask; |
| - uint32_t ring_entries; |
| - uint32_t overflow; |
| - uint32_t cqes; |
| - uint64_t reserved0; |
| - uint64_t reserved1; |
| -}; |
| - |
| -STATIC_ASSERT(40 == sizeof(struct uv__io_cqring_offsets)); |
| - |
| -struct uv__io_sqring_offsets { |
| - uint32_t head; |
| - uint32_t tail; |
| - uint32_t ring_mask; |
| - uint32_t ring_entries; |
| - uint32_t flags; |
| - uint32_t dropped; |
| - uint32_t array; |
| - uint32_t reserved0; |
| - uint64_t reserved1; |
| -}; |
| - |
| -STATIC_ASSERT(40 == sizeof(struct uv__io_sqring_offsets)); |
| - |
| -struct uv__io_uring_cqe { |
| - uint64_t user_data; |
| - int32_t res; |
| - uint32_t flags; |
| -}; |
| - |
| -STATIC_ASSERT(16 == sizeof(struct uv__io_uring_cqe)); |
| - |
| -struct uv__io_uring_sqe { |
| - uint8_t opcode; |
| - uint8_t flags; |
| - uint16_t ioprio; |
| - int32_t fd; |
| - union { |
| - uint64_t off; |
| - uint64_t addr2; |
| - }; |
| - union { |
| - uint64_t addr; |
| - }; |
| - uint32_t len; |
| - union { |
| - uint32_t rw_flags; |
| - uint32_t fsync_flags; |
| - uint32_t open_flags; |
| - uint32_t statx_flags; |
| - }; |
| - uint64_t user_data; |
| - union { |
| - uint16_t buf_index; |
| - uint64_t pad[3]; |
| - }; |
| -}; |
| - |
| -STATIC_ASSERT(64 == sizeof(struct uv__io_uring_sqe)); |
| -STATIC_ASSERT(0 == offsetof(struct uv__io_uring_sqe, opcode)); |
| -STATIC_ASSERT(1 == offsetof(struct uv__io_uring_sqe, flags)); |
| -STATIC_ASSERT(2 == offsetof(struct uv__io_uring_sqe, ioprio)); |
| -STATIC_ASSERT(4 == offsetof(struct uv__io_uring_sqe, fd)); |
| -STATIC_ASSERT(8 == offsetof(struct uv__io_uring_sqe, off)); |
| -STATIC_ASSERT(16 == offsetof(struct uv__io_uring_sqe, addr)); |
| -STATIC_ASSERT(24 == offsetof(struct uv__io_uring_sqe, len)); |
| -STATIC_ASSERT(28 == offsetof(struct uv__io_uring_sqe, rw_flags)); |
| -STATIC_ASSERT(32 == offsetof(struct uv__io_uring_sqe, user_data)); |
| -STATIC_ASSERT(40 == offsetof(struct uv__io_uring_sqe, buf_index)); |
| - |
| -struct uv__io_uring_params { |
| - uint32_t sq_entries; |
| - uint32_t cq_entries; |
| - uint32_t flags; |
| - uint32_t sq_thread_cpu; |
| - uint32_t sq_thread_idle; |
| - uint32_t features; |
| - uint32_t reserved[4]; |
| - struct uv__io_sqring_offsets sq_off; /* 40 bytes */ |
| - struct uv__io_cqring_offsets cq_off; /* 40 bytes */ |
| -}; |
| - |
| -STATIC_ASSERT(40 + 40 + 40 == sizeof(struct uv__io_uring_params)); |
| -STATIC_ASSERT(40 == offsetof(struct uv__io_uring_params, sq_off)); |
| -STATIC_ASSERT(80 == offsetof(struct uv__io_uring_params, cq_off)); |
| - |
| -STATIC_ASSERT(EPOLL_CTL_ADD < 4); |
| -STATIC_ASSERT(EPOLL_CTL_DEL < 4); |
| -STATIC_ASSERT(EPOLL_CTL_MOD < 4); |
| - |
| struct watcher_list { |
| RB_ENTRY(watcher_list) entry; |
| QUEUE watchers; |
| @@ -276,17 +137,6 @@ static int compare_watchers(const struct watcher_list* a, |
| static void maybe_free_watcher_list(struct watcher_list* w, |
| uv_loop_t* loop); |
| |
| -static void uv__epoll_ctl_flush(int epollfd, |
| - struct uv__iou* ctl, |
| - struct epoll_event (*events)[256]); |
| - |
| -static void uv__epoll_ctl_prep(int epollfd, |
| - struct uv__iou* ctl, |
| - struct epoll_event (*events)[256], |
| - int op, |
| - int fd, |
| - struct epoll_event* e); |
| - |
| RB_GENERATE_STATIC(watcher_root, watcher_list, entry, compare_watchers) |
| |
| |
| @@ -356,187 +206,7 @@ ssize_t uv__getrandom(void* buf, size_t buflen, unsigned flags) { |
| } |
| |
| |
| -int uv__io_uring_setup(int entries, struct uv__io_uring_params* params) { |
| - return syscall(__NR_io_uring_setup, entries, params); |
| -} |
| - |
| - |
| -int uv__io_uring_enter(int fd, |
| - unsigned to_submit, |
| - unsigned min_complete, |
| - unsigned flags) { |
| - /* io_uring_enter used to take a sigset_t but it's unused |
| - * in newer kernels unless IORING_ENTER_EXT_ARG is set, |
| - * in which case it takes a struct io_uring_getevents_arg. |
| - */ |
| - return syscall(__NR_io_uring_enter, |
| - fd, |
| - to_submit, |
| - min_complete, |
| - flags, |
| - NULL, |
| - 0L); |
| -} |
| - |
| - |
| -int uv__io_uring_register(int fd, unsigned opcode, void* arg, unsigned nargs) { |
| - return syscall(__NR_io_uring_register, fd, opcode, arg, nargs); |
| -} |
| - |
| - |
| -static int uv__use_io_uring(void) { |
| - /* Ternary: unknown=0, yes=1, no=-1 */ |
| - static _Atomic int use_io_uring; |
| - char* val; |
| - int use; |
| - |
| - use = atomic_load_explicit(&use_io_uring, memory_order_relaxed); |
| - |
| - if (use == 0) { |
| - val = getenv("UV_USE_IO_URING"); |
| - use = val == NULL || atoi(val) ? 1 : -1; |
| - atomic_store_explicit(&use_io_uring, use, memory_order_relaxed); |
| - } |
| - |
| - return use > 0; |
| -} |
| - |
| - |
| -static void uv__iou_init(int epollfd, |
| - struct uv__iou* iou, |
| - uint32_t entries, |
| - uint32_t flags) { |
| - struct uv__io_uring_params params; |
| - struct epoll_event e; |
| - size_t cqlen; |
| - size_t sqlen; |
| - size_t maxlen; |
| - size_t sqelen; |
| - uint32_t i; |
| - char* sq; |
| - char* sqe; |
| - int ringfd; |
| - |
| - sq = MAP_FAILED; |
| - sqe = MAP_FAILED; |
| - |
| - if (!uv__use_io_uring()) |
| - return; |
| - |
| - /* SQPOLL required CAP_SYS_NICE until linux v5.12 relaxed that requirement. |
| - * Mostly academic because we check for a v5.13 kernel afterwards anyway. |
| - */ |
| - memset(¶ms, 0, sizeof(params)); |
| - params.flags = flags; |
| - |
| - if (flags & UV__IORING_SETUP_SQPOLL) |
| - params.sq_thread_idle = 10; /* milliseconds */ |
| - |
| - /* Kernel returns a file descriptor with O_CLOEXEC flag set. */ |
| - ringfd = uv__io_uring_setup(entries, ¶ms); |
| - if (ringfd == -1) |
| - return; |
| - |
| - /* IORING_FEAT_RSRC_TAGS is used to detect linux v5.13 but what we're |
| - * actually detecting is whether IORING_OP_STATX works with SQPOLL. |
| - */ |
| - if (!(params.features & UV__IORING_FEAT_RSRC_TAGS)) |
| - goto fail; |
| - |
| - /* Implied by IORING_FEAT_RSRC_TAGS but checked explicitly anyway. */ |
| - if (!(params.features & UV__IORING_FEAT_SINGLE_MMAP)) |
| - goto fail; |
| - |
| - /* Implied by IORING_FEAT_RSRC_TAGS but checked explicitly anyway. */ |
| - if (!(params.features & UV__IORING_FEAT_NODROP)) |
| - goto fail; |
| - |
| - sqlen = params.sq_off.array + params.sq_entries * sizeof(uint32_t); |
| - cqlen = |
| - params.cq_off.cqes + params.cq_entries * sizeof(struct uv__io_uring_cqe); |
| - maxlen = sqlen < cqlen ? cqlen : sqlen; |
| - sqelen = params.sq_entries * sizeof(struct uv__io_uring_sqe); |
| - |
| - sq = mmap(0, |
| - maxlen, |
| - PROT_READ | PROT_WRITE, |
| - MAP_SHARED | MAP_POPULATE, |
| - ringfd, |
| - 0); /* IORING_OFF_SQ_RING */ |
| - |
| - sqe = mmap(0, |
| - sqelen, |
| - PROT_READ | PROT_WRITE, |
| - MAP_SHARED | MAP_POPULATE, |
| - ringfd, |
| - 0x10000000ull); /* IORING_OFF_SQES */ |
| - |
| - if (sq == MAP_FAILED || sqe == MAP_FAILED) |
| - goto fail; |
| - |
| - if (flags & UV__IORING_SETUP_SQPOLL) { |
| - /* Only interested in completion events. To get notified when |
| - * the kernel pulls items from the submission ring, add POLLOUT. |
| - */ |
| - memset(&e, 0, sizeof(e)); |
| - e.events = POLLIN; |
| - e.data.fd = ringfd; |
| - |
| - if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ringfd, &e)) |
| - goto fail; |
| - } |
| - |
| - iou->sqhead = (uint32_t*) (sq + params.sq_off.head); |
| - iou->sqtail = (uint32_t*) (sq + params.sq_off.tail); |
| - iou->sqmask = *(uint32_t*) (sq + params.sq_off.ring_mask); |
| - iou->sqarray = (uint32_t*) (sq + params.sq_off.array); |
| - iou->sqflags = (uint32_t*) (sq + params.sq_off.flags); |
| - iou->cqhead = (uint32_t*) (sq + params.cq_off.head); |
| - iou->cqtail = (uint32_t*) (sq + params.cq_off.tail); |
| - iou->cqmask = *(uint32_t*) (sq + params.cq_off.ring_mask); |
| - iou->sq = sq; |
| - iou->cqe = sq + params.cq_off.cqes; |
| - iou->sqe = sqe; |
| - iou->sqlen = sqlen; |
| - iou->cqlen = cqlen; |
| - iou->maxlen = maxlen; |
| - iou->sqelen = sqelen; |
| - iou->ringfd = ringfd; |
| - iou->in_flight = 0; |
| - |
| - for (i = 0; i <= iou->sqmask; i++) |
| - iou->sqarray[i] = i; /* Slot -> sqe identity mapping. */ |
| - |
| - return; |
| - |
| -fail: |
| - if (sq != MAP_FAILED) |
| - munmap(sq, maxlen); |
| - |
| - if (sqe != MAP_FAILED) |
| - munmap(sqe, sqelen); |
| - |
| - uv__close(ringfd); |
| -} |
| - |
| - |
| -static void uv__iou_delete(struct uv__iou* iou) { |
| - if (iou->ringfd != -1) { |
| - munmap(iou->sq, iou->maxlen); |
| - munmap(iou->sqe, iou->sqelen); |
| - uv__close(iou->ringfd); |
| - iou->ringfd = -1; |
| - } |
| -} |
| - |
| - |
| int uv__platform_loop_init(uv_loop_t* loop) { |
| - uv__loop_internal_fields_t* lfields; |
| - |
| - lfields = uv__get_internal_fields(loop); |
| - lfields->ctl.ringfd = -1; |
| - lfields->iou.ringfd = -1; |
| - |
| loop->inotify_watchers = NULL; |
| loop->inotify_fd = -1; |
| loop->backend_fd = epoll_create1(O_CLOEXEC); |
| @@ -544,9 +214,6 @@ int uv__platform_loop_init(uv_loop_t* loop) { |
| if (loop->backend_fd == -1) |
| return UV__ERR(errno); |
| |
| - uv__iou_init(loop->backend_fd, &lfields->iou, 64, UV__IORING_SETUP_SQPOLL); |
| - uv__iou_init(loop->backend_fd, &lfields->ctl, 256, 0); |
| - |
| return 0; |
| } |
| |
| @@ -559,8 +226,6 @@ int uv__io_fork(uv_loop_t* loop) { |
| |
| uv__close(loop->backend_fd); |
| loop->backend_fd = -1; |
| - |
| - /* TODO(bnoordhuis) Loses items from the submission and completion rings. */ |
| uv__platform_loop_delete(loop); |
| |
| err = uv__platform_loop_init(loop); |
| @@ -572,62 +237,42 @@ int uv__io_fork(uv_loop_t* loop) { |
| |
| |
| void uv__platform_loop_delete(uv_loop_t* loop) { |
| - uv__loop_internal_fields_t* lfields; |
| - |
| - lfields = uv__get_internal_fields(loop); |
| - uv__iou_delete(&lfields->ctl); |
| - uv__iou_delete(&lfields->iou); |
| - |
| - if (loop->inotify_fd != -1) { |
| - uv__io_stop(loop, &loop->inotify_read_watcher, POLLIN); |
| - uv__close(loop->inotify_fd); |
| - loop->inotify_fd = -1; |
| - } |
| + if (loop->inotify_fd == -1) return; |
| + uv__io_stop(loop, &loop->inotify_read_watcher, POLLIN); |
| + uv__close(loop->inotify_fd); |
| + loop->inotify_fd = -1; |
| } |
| |
| |
| -struct uv__invalidate { |
| - struct epoll_event (*prep)[256]; |
| - struct epoll_event* events; |
| - int nfds; |
| -}; |
| - |
| - |
| void uv__platform_invalidate_fd(uv_loop_t* loop, int fd) { |
| - uv__loop_internal_fields_t* lfields; |
| - struct uv__invalidate* inv; |
| + struct epoll_event* events; |
| struct epoll_event dummy; |
| - int i; |
| + uintptr_t i; |
| + uintptr_t nfds; |
| |
| - lfields = uv__get_internal_fields(loop); |
| - inv = lfields->inv; |
| + assert(loop->watchers != NULL); |
| + assert(fd >= 0); |
| |
| - /* Invalidate events with same file descriptor */ |
| - if (inv != NULL) |
| - for (i = 0; i < inv->nfds; i++) |
| - if (inv->events[i].data.fd == fd) |
| - inv->events[i].data.fd = -1; |
| + events = (struct epoll_event*) loop->watchers[loop->nwatchers]; |
| + nfds = (uintptr_t) loop->watchers[loop->nwatchers + 1]; |
| + if (events != NULL) |
| + /* Invalidate events with same file descriptor */ |
| + for (i = 0; i < nfds; i++) |
| + if (events[i].data.fd == fd) |
| + events[i].data.fd = -1; |
| |
| /* Remove the file descriptor from the epoll. |
| * This avoids a problem where the same file description remains open |
| * in another process, causing repeated junk epoll events. |
| * |
| * We pass in a dummy epoll_event, to work around a bug in old kernels. |
| - * |
| - * Work around a bug in kernels 3.10 to 3.19 where passing a struct that |
| - * has the EPOLLWAKEUP flag set generates spurious audit syslog warnings. |
| */ |
| - memset(&dummy, 0, sizeof(dummy)); |
| - |
| - if (inv == NULL) { |
| + if (loop->backend_fd >= 0) { |
| + /* Work around a bug in kernels 3.10 to 3.19 where passing a struct that |
| + * has the EPOLLWAKEUP flag set generates spurious audit syslog warnings. |
| + */ |
| + memset(&dummy, 0, sizeof(dummy)); |
| epoll_ctl(loop->backend_fd, EPOLL_CTL_DEL, fd, &dummy); |
| - } else { |
| - uv__epoll_ctl_prep(loop->backend_fd, |
| - &lfields->ctl, |
| - inv->prep, |
| - EPOLL_CTL_DEL, |
| - fd, |
| - &dummy); |
| } |
| } |
| |
| @@ -653,454 +298,27 @@ int uv__io_check_fd(uv_loop_t* loop, int fd) { |
| } |
| |
| |
| -/* Caller must initialize SQE and call uv__iou_submit(). */ |
| -static struct uv__io_uring_sqe* uv__iou_get_sqe(struct uv__iou* iou, |
| - uv_loop_t* loop, |
| - uv_fs_t* req) { |
| - struct uv__io_uring_sqe* sqe; |
| - uint32_t head; |
| - uint32_t tail; |
| - uint32_t mask; |
| - uint32_t slot; |
| - |
| - if (iou->ringfd == -1) |
| - return NULL; |
| - |
| - head = atomic_load_explicit((_Atomic uint32_t*) iou->sqhead, |
| - memory_order_acquire); |
| - tail = *iou->sqtail; |
| - mask = iou->sqmask; |
| - |
| - if ((head & mask) == ((tail + 1) & mask)) |
| - return NULL; /* No room in ring buffer. TODO(bnoordhuis) maybe flush it? */ |
| - |
| - slot = tail & mask; |
| - sqe = iou->sqe; |
| - sqe = &sqe[slot]; |
| - memset(sqe, 0, sizeof(*sqe)); |
| - sqe->user_data = (uintptr_t) req; |
| - |
| - /* Pacify uv_cancel(). */ |
| - req->work_req.loop = loop; |
| - req->work_req.work = NULL; |
| - req->work_req.done = NULL; |
| - QUEUE_INIT(&req->work_req.wq); |
| - |
| - uv__req_register(loop, req); |
| - iou->in_flight++; |
| - |
| - return sqe; |
| -} |
| - |
| - |
| -static void uv__iou_submit(struct uv__iou* iou) { |
| - uint32_t flags; |
| - |
| - atomic_store_explicit((_Atomic uint32_t*) iou->sqtail, |
| - *iou->sqtail + 1, |
| - memory_order_release); |
| - |
| - flags = atomic_load_explicit((_Atomic uint32_t*) iou->sqflags, |
| - memory_order_acquire); |
| - |
| - if (flags & UV__IORING_SQ_NEED_WAKEUP) |
| - if (uv__io_uring_enter(iou->ringfd, 0, 0, UV__IORING_ENTER_SQ_WAKEUP)) |
| - if (errno != EOWNERDEAD) /* Kernel bug. Harmless, ignore. */ |
| - perror("libuv: io_uring_enter(wakeup)"); /* Can't happen. */ |
| -} |
| - |
| - |
| -int uv__iou_fs_close(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->fd = req->file; |
| - sqe->opcode = UV__IORING_OP_CLOSE; |
| - |
| - uv__iou_submit(iou); |
| - |
| - return 1; |
| -} |
| - |
| - |
| -int uv__iou_fs_fsync_or_fdatasync(uv_loop_t* loop, |
| - uv_fs_t* req, |
| - uint32_t fsync_flags) { |
| - 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; |
| - |
| - /* Little known fact: setting seq->off and seq->len turns |
| - * it into an asynchronous sync_file_range() operation. |
| - */ |
| - sqe->fd = req->file; |
| - sqe->fsync_flags = fsync_flags; |
| - sqe->opcode = UV__IORING_OP_FSYNC; |
| - |
| - 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; |
| - |
| - 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->len = req->mode; |
| - sqe->opcode = UV__IORING_OP_OPENAT; |
| - sqe->open_flags = req->flags | O_CLOEXEC; |
| - |
| - 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; |
| - |
| - /* 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; |
| - |
| - sqe = uv__iou_get_sqe(iou, loop, req); |
| - if (sqe == NULL) |
| - return 0; |
| - |
| - sqe->addr = (uintptr_t) req->bufs; |
| - sqe->fd = req->file; |
| - sqe->len = req->nbufs; |
| - sqe->off = req->off < 0 ? -1 : req->off; |
| - sqe->opcode = is_read ? UV__IORING_OP_READV : UV__IORING_OP_WRITEV; |
| - |
| - uv__iou_submit(iou); |
| - |
| - return 1; |
| -} |
| - |
| - |
| -int uv__iou_fs_statx(uv_loop_t* loop, |
| - uv_fs_t* req, |
| - int is_fstat, |
| - int is_lstat) { |
| - struct uv__io_uring_sqe* sqe; |
| - struct uv__statx* statxbuf; |
| - struct uv__iou* iou; |
| - |
| - statxbuf = uv__malloc(sizeof(*statxbuf)); |
| - if (statxbuf == NULL) |
| - return 0; |
| - |
| - iou = &uv__get_internal_fields(loop)->iou; |
| - |
| - sqe = uv__iou_get_sqe(iou, loop, req); |
| - if (sqe == NULL) { |
| - uv__free(statxbuf); |
| - return 0; |
| - } |
| - |
| - req->ptr = statxbuf; |
| - |
| - sqe->addr = (uintptr_t) req->path; |
| - sqe->addr2 = (uintptr_t) statxbuf; |
| - sqe->fd = AT_FDCWD; |
| - sqe->len = 0xFFF; /* STATX_BASIC_STATS + STATX_BTIME */ |
| - sqe->opcode = UV__IORING_OP_STATX; |
| - |
| - if (is_fstat) { |
| - sqe->addr = (uintptr_t) ""; |
| - sqe->fd = req->file; |
| - sqe->statx_flags |= 0x1000; /* AT_EMPTY_PATH */ |
| - } |
| - |
| - if (is_lstat) |
| - sqe->statx_flags |= AT_SYMLINK_NOFOLLOW; |
| - |
| - uv__iou_submit(iou); |
| - |
| - return 1; |
| -} |
| - |
| - |
| -void uv__statx_to_stat(const struct uv__statx* statxbuf, uv_stat_t* buf) { |
| - buf->st_dev = makedev(statxbuf->stx_dev_major, statxbuf->stx_dev_minor); |
| - buf->st_mode = statxbuf->stx_mode; |
| - buf->st_nlink = statxbuf->stx_nlink; |
| - buf->st_uid = statxbuf->stx_uid; |
| - buf->st_gid = statxbuf->stx_gid; |
| - buf->st_rdev = makedev(statxbuf->stx_rdev_major, statxbuf->stx_rdev_minor); |
| - buf->st_ino = statxbuf->stx_ino; |
| - buf->st_size = statxbuf->stx_size; |
| - buf->st_blksize = statxbuf->stx_blksize; |
| - buf->st_blocks = statxbuf->stx_blocks; |
| - buf->st_atim.tv_sec = statxbuf->stx_atime.tv_sec; |
| - buf->st_atim.tv_nsec = statxbuf->stx_atime.tv_nsec; |
| - buf->st_mtim.tv_sec = statxbuf->stx_mtime.tv_sec; |
| - buf->st_mtim.tv_nsec = statxbuf->stx_mtime.tv_nsec; |
| - buf->st_ctim.tv_sec = statxbuf->stx_ctime.tv_sec; |
| - buf->st_ctim.tv_nsec = statxbuf->stx_ctime.tv_nsec; |
| - buf->st_birthtim.tv_sec = statxbuf->stx_btime.tv_sec; |
| - buf->st_birthtim.tv_nsec = statxbuf->stx_btime.tv_nsec; |
| - buf->st_flags = 0; |
| - buf->st_gen = 0; |
| -} |
| - |
| - |
| -static void uv__iou_fs_statx_post(uv_fs_t* req) { |
| - struct uv__statx* statxbuf; |
| - uv_stat_t* buf; |
| - |
| - buf = &req->statbuf; |
| - statxbuf = req->ptr; |
| - req->ptr = NULL; |
| - |
| - if (req->result == 0) { |
| - uv__msan_unpoison(statxbuf, sizeof(*statxbuf)); |
| - uv__statx_to_stat(statxbuf, buf); |
| - req->ptr = buf; |
| - } |
| - |
| - uv__free(statxbuf); |
| -} |
| - |
| - |
| -static void uv__poll_io_uring(uv_loop_t* loop, struct uv__iou* iou) { |
| - struct uv__io_uring_cqe* cqe; |
| - struct uv__io_uring_cqe* e; |
| - uv_fs_t* req; |
| - uint32_t head; |
| - uint32_t tail; |
| - uint32_t mask; |
| - uint32_t i; |
| - uint32_t flags; |
| - int nevents; |
| - int rc; |
| - |
| - head = *iou->cqhead; |
| - tail = atomic_load_explicit((_Atomic uint32_t*) iou->cqtail, |
| - memory_order_acquire); |
| - mask = iou->cqmask; |
| - cqe = iou->cqe; |
| - nevents = 0; |
| - |
| - for (i = head; i != tail; i++) { |
| - e = &cqe[i & mask]; |
| - |
| - req = (uv_fs_t*) (uintptr_t) e->user_data; |
| - assert(req->type == UV_FS); |
| - |
| - uv__req_unregister(loop, req); |
| - iou->in_flight--; |
| - |
| - /* io_uring stores error codes as negative numbers, same as libuv. */ |
| - req->result = e->res; |
| - |
| - switch (req->fs_type) { |
| - case UV_FS_FSTAT: |
| - case UV_FS_LSTAT: |
| - case UV_FS_STAT: |
| - uv__iou_fs_statx_post(req); |
| - break; |
| - default: /* Squelch -Wswitch warnings. */ |
| - break; |
| - } |
| - |
| - uv__metrics_update_idle_time(loop); |
| - req->cb(req); |
| - nevents++; |
| - } |
| - |
| - atomic_store_explicit((_Atomic uint32_t*) iou->cqhead, |
| - tail, |
| - memory_order_release); |
| - |
| - /* Check whether CQE's overflowed, if so enter the kernel to make them |
| - * available. Don't grab them immediately but in the next loop iteration to |
| - * avoid loop starvation. */ |
| - flags = atomic_load_explicit((_Atomic uint32_t*) iou->sqflags, |
| - memory_order_acquire); |
| - |
| - if (flags & UV__IORING_SQ_CQ_OVERFLOW) { |
| - do |
| - rc = uv__io_uring_enter(iou->ringfd, 0, 0, UV__IORING_ENTER_GETEVENTS); |
| - while (rc == -1 && errno == EINTR); |
| - |
| - if (rc < 0) |
| - perror("libuv: io_uring_enter(getevents)"); /* Can't happen. */ |
| - } |
| - |
| - uv__metrics_inc_events(loop, nevents); |
| - if (uv__get_internal_fields(loop)->current_timeout == 0) |
| - uv__metrics_inc_events_waiting(loop, nevents); |
| -} |
| - |
| - |
| -static void uv__epoll_ctl_prep(int epollfd, |
| - struct uv__iou* ctl, |
| - struct epoll_event (*events)[256], |
| - int op, |
| - int fd, |
| - struct epoll_event* e) { |
| - struct uv__io_uring_sqe* sqe; |
| - struct epoll_event* pe; |
| - uint32_t mask; |
| - uint32_t slot; |
| - |
| - if (ctl->ringfd == -1) { |
| - if (!epoll_ctl(epollfd, op, fd, e)) |
| - return; |
| - |
| - if (op == EPOLL_CTL_DEL) |
| - return; /* Ignore errors, may be racing with another thread. */ |
| - |
| - if (op != EPOLL_CTL_ADD) |
| - abort(); |
| - |
| - if (errno != EEXIST) |
| - abort(); |
| - |
| - /* File descriptor that's been watched before, update event mask. */ |
| - if (!epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, e)) |
| - return; |
| - |
| - abort(); |
| - } else { |
| - mask = ctl->sqmask; |
| - slot = (*ctl->sqtail)++ & mask; |
| - |
| - pe = &(*events)[slot]; |
| - *pe = *e; |
| - |
| - sqe = ctl->sqe; |
| - sqe = &sqe[slot]; |
| - |
| - memset(sqe, 0, sizeof(*sqe)); |
| - sqe->addr = (uintptr_t) pe; |
| - sqe->fd = epollfd; |
| - sqe->len = op; |
| - sqe->off = fd; |
| - sqe->opcode = UV__IORING_OP_EPOLL_CTL; |
| - sqe->user_data = op | slot << 2 | (int64_t) fd << 32; |
| - |
| - if ((*ctl->sqhead & mask) == (*ctl->sqtail & mask)) |
| - uv__epoll_ctl_flush(epollfd, ctl, events); |
| - } |
| -} |
| - |
| - |
| -static void uv__epoll_ctl_flush(int epollfd, |
| - struct uv__iou* ctl, |
| - struct epoll_event (*events)[256]) { |
| - struct epoll_event oldevents[256]; |
| - struct uv__io_uring_cqe* cqe; |
| - uint32_t oldslot; |
| - uint32_t slot; |
| - uint32_t n; |
| - int fd; |
| - int op; |
| - int rc; |
| - |
| - STATIC_ASSERT(sizeof(oldevents) == sizeof(*events)); |
| - assert(ctl->ringfd != -1); |
| - assert(*ctl->sqhead != *ctl->sqtail); |
| - |
| - n = *ctl->sqtail - *ctl->sqhead; |
| - do |
| - rc = uv__io_uring_enter(ctl->ringfd, n, n, UV__IORING_ENTER_GETEVENTS); |
| - while (rc == -1 && errno == EINTR); |
| - |
| - if (rc < 0) |
| - perror("libuv: io_uring_enter(getevents)"); /* Can't happen. */ |
| - |
| - if (rc != (int) n) |
| - abort(); |
| - |
| - assert(*ctl->sqhead == *ctl->sqtail); |
| - |
| - memcpy(oldevents, *events, sizeof(*events)); |
| - |
| - /* Failed submissions are either EPOLL_CTL_DEL commands for file descriptors |
| - * that have been closed, or EPOLL_CTL_ADD commands for file descriptors |
| - * that we are already watching. Ignore the former and retry the latter |
| - * with EPOLL_CTL_MOD. |
| - */ |
| - while (*ctl->cqhead != *ctl->cqtail) { |
| - slot = (*ctl->cqhead)++ & ctl->cqmask; |
| - |
| - cqe = ctl->cqe; |
| - cqe = &cqe[slot]; |
| - |
| - if (cqe->res == 0) |
| - continue; |
| - |
| - fd = cqe->user_data >> 32; |
| - op = 3 & cqe->user_data; |
| - oldslot = 255 & (cqe->user_data >> 2); |
| - |
| - if (op == EPOLL_CTL_DEL) |
| - continue; |
| - |
| - if (op != EPOLL_CTL_ADD) |
| - abort(); |
| - |
| - if (cqe->res != -EEXIST) |
| - abort(); |
| - |
| - uv__epoll_ctl_prep(epollfd, |
| - ctl, |
| - events, |
| - EPOLL_CTL_MOD, |
| - fd, |
| - &oldevents[oldslot]); |
| - } |
| -} |
| - |
| - |
| void uv__io_poll(uv_loop_t* loop, int timeout) { |
| - uv__loop_internal_fields_t* lfields; |
| + /* A bug in kernels < 2.6.37 makes timeouts larger than ~30 minutes |
| + * effectively infinite on 32 bits architectures. To avoid blocking |
| + * indefinitely, we cap the timeout and poll again if necessary. |
| + * |
| + * Note that "30 minutes" is a simplification because it depends on |
| + * the value of CONFIG_HZ. The magic constant assumes CONFIG_HZ=1200, |
| + * that being the largest value I have seen in the wild (and only once.) |
| + */ |
| + static const int max_safe_timeout = 1789569; |
| struct epoll_event events[1024]; |
| - struct epoll_event prep[256]; |
| - struct uv__invalidate inv; |
| struct epoll_event* pe; |
| struct epoll_event e; |
| - struct uv__iou* ctl; |
| - struct uv__iou* iou; |
| int real_timeout; |
| QUEUE* q; |
| uv__io_t* w; |
| sigset_t* sigmask; |
| sigset_t sigset; |
| uint64_t base; |
| - int have_iou_events; |
| int have_signals; |
| int nevents; |
| - int epollfd; |
| int count; |
| int nfds; |
| int fd; |
| @@ -1109,9 +327,47 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| int user_timeout; |
| int reset_timeout; |
| |
| - lfields = uv__get_internal_fields(loop); |
| - ctl = &lfields->ctl; |
| - iou = &lfields->iou; |
| + if (loop->nfds == 0) { |
| + assert(QUEUE_EMPTY(&loop->watcher_queue)); |
| + return; |
| + } |
| + |
| + memset(&e, 0, sizeof(e)); |
| + |
| + while (!QUEUE_EMPTY(&loop->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); |
| + assert(w->fd < (int) loop->nwatchers); |
| + |
| + e.events = w->pevents; |
| + e.data.fd = w->fd; |
| + |
| + if (w->events == 0) |
| + op = EPOLL_CTL_ADD; |
| + else |
| + op = EPOLL_CTL_MOD; |
| + |
| + /* XXX Future optimization: do EPOLL_CTL_MOD lazily if we stop watching |
| + * events, skip the syscall and squelch the events after epoll_wait(). |
| + */ |
| + if (epoll_ctl(loop->backend_fd, op, w->fd, &e)) { |
| + if (errno != EEXIST) |
| + abort(); |
| + |
| + assert(op == EPOLL_CTL_ADD); |
| + |
| + /* We've reactivated a file descriptor that's been watched before. */ |
| + if (epoll_ctl(loop->backend_fd, EPOLL_CTL_MOD, w->fd, &e)) |
| + abort(); |
| + } |
| + |
| + w->events = w->pevents; |
| + } |
| |
| sigmask = NULL; |
| if (loop->flags & UV_LOOP_BLOCK_SIGPROF) { |
| @@ -1125,7 +381,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| count = 48; /* Benchmarks suggest this gives the best throughput. */ |
| real_timeout = timeout; |
| |
| - if (lfields->flags & UV_METRICS_IDLE_TIME) { |
| + if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) { |
| reset_timeout = 1; |
| user_timeout = timeout; |
| timeout = 0; |
| @@ -1134,56 +390,24 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| user_timeout = 0; |
| } |
| |
| - epollfd = loop->backend_fd; |
| - |
| - memset(&e, 0, sizeof(e)); |
| - |
| - 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) |
| - op = EPOLL_CTL_ADD; |
| - |
| - w->events = w->pevents; |
| - e.events = w->pevents; |
| - e.data.fd = w->fd; |
| - |
| - uv__epoll_ctl_prep(epollfd, ctl, &prep, op, w->fd, &e); |
| - } |
| - |
| - inv.events = events; |
| - inv.prep = &prep; |
| - inv.nfds = -1; |
| - |
| for (;;) { |
| - if (loop->nfds == 0) |
| - if (iou->in_flight == 0) |
| - break; |
| - |
| - /* All event mask mutations should be visible to the kernel before |
| - * we enter epoll_pwait(). |
| - */ |
| - if (ctl->ringfd != -1) |
| - while (*ctl->sqhead != *ctl->sqtail) |
| - uv__epoll_ctl_flush(epollfd, ctl, &prep); |
| - |
| /* Only need to set the provider_entry_time if timeout != 0. The function |
| * will return early if the loop isn't configured with UV_METRICS_IDLE_TIME. |
| */ |
| if (timeout != 0) |
| uv__metrics_set_provider_entry_time(loop); |
| |
| - /* Store the current timeout in a location that's globally accessible so |
| - * other locations like uv__work_done() can determine whether the queue |
| - * of events in the callback were waiting when poll was called. |
| + /* See the comment for max_safe_timeout for an explanation of why |
| + * this is necessary. Executive summary: kernel bug workaround. |
| */ |
| - lfields->current_timeout = timeout; |
| + if (sizeof(int32_t) == sizeof(long) && timeout >= max_safe_timeout) |
| + timeout = max_safe_timeout; |
| |
| - nfds = epoll_pwait(epollfd, events, ARRAY_SIZE(events), timeout, sigmask); |
| + nfds = epoll_pwait(loop->backend_fd, |
| + events, |
| + ARRAY_SIZE(events), |
| + timeout, |
| + sigmask); |
| |
| /* Update loop->time unconditionally. It's tempting to skip the update when |
| * timeout == 0 (i.e. non-blocking poll) but there is no guarantee that the |
| @@ -1203,7 +427,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| continue; |
| |
| if (timeout == 0) |
| - break; |
| + return; |
| |
| /* We may have been inside the system call for longer than |timeout| |
| * milliseconds so we need to update the timestamp to avoid drift. |
| @@ -1224,18 +448,27 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| continue; |
| |
| if (timeout == 0) |
| - break; |
| + return; |
| |
| /* Interrupted by a signal. Update timeout and poll again. */ |
| goto update_timeout; |
| } |
| |
| - have_iou_events = 0; |
| have_signals = 0; |
| nevents = 0; |
| |
| - inv.nfds = nfds; |
| - lfields->inv = &inv; |
| + { |
| + /* Squelch a -Waddress-of-packed-member warning with gcc >= 9. */ |
| + union { |
| + struct epoll_event* events; |
| + uv__io_t* watchers; |
| + } x; |
| + |
| + x.events = events; |
| + assert(loop->watchers != NULL); |
| + loop->watchers[loop->nwatchers] = x.watchers; |
| + loop->watchers[loop->nwatchers + 1] = (void*) (uintptr_t) nfds; |
| + } |
| |
| for (i = 0; i < nfds; i++) { |
| pe = events + i; |
| @@ -1245,12 +478,6 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| if (fd == -1) |
| continue; |
| |
| - if (fd == iou->ringfd) { |
| - uv__poll_io_uring(loop, iou); |
| - have_iou_events = 1; |
| - continue; |
| - } |
| - |
| assert(fd >= 0); |
| assert((unsigned) fd < loop->nwatchers); |
| |
| @@ -1262,7 +489,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| * Ignore all errors because we may be racing with another thread |
| * when the file descriptor is closed. |
| */ |
| - uv__epoll_ctl_prep(epollfd, ctl, &prep, EPOLL_CTL_DEL, fd, pe); |
| + epoll_ctl(loop->backend_fd, EPOLL_CTL_DEL, fd, pe); |
| continue; |
| } |
| |
| @@ -1319,13 +546,11 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| loop->signal_io_watcher.cb(loop, &loop->signal_io_watcher, POLLIN); |
| } |
| |
| - lfields->inv = NULL; |
| - |
| - if (have_iou_events != 0) |
| - break; /* Event loop should cycle now so don't poll again. */ |
| + loop->watchers[loop->nwatchers] = NULL; |
| + loop->watchers[loop->nwatchers + 1] = NULL; |
| |
| if (have_signals != 0) |
| - break; /* Event loop should cycle now so don't poll again. */ |
| + return; /* Event loop should cycle now so don't poll again. */ |
| |
| if (nevents != 0) { |
| if (nfds == ARRAY_SIZE(events) && --count != 0) { |
| @@ -1333,11 +558,11 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| timeout = 0; |
| continue; |
| } |
| - break; |
| + return; |
| } |
| |
| if (timeout == 0) |
| - break; |
| + return; |
| |
| if (timeout == -1) |
| continue; |
| @@ -1347,14 +572,10 @@ update_timeout: |
| |
| real_timeout -= (loop->time - base); |
| if (real_timeout <= 0) |
| - break; |
| + return; |
| |
| timeout = real_timeout; |
| } |
| - |
| - if (ctl->ringfd != -1) |
| - while (*ctl->sqhead != *ctl->sqtail) |
| - uv__epoll_ctl_flush(epollfd, ctl, &prep); |
| } |
| |
| uint64_t uv__hrtime(uv_clocktype_t type) { |
| @@ -1867,7 +1088,7 @@ static uint64_t uv__read_uint64(const char* filename) { |
| if (0 == uv__slurp(filename, buf, sizeof(buf))) |
| if (1 != sscanf(buf, "%" PRIu64, &rc)) |
| if (0 == strcmp(buf, "max\n")) |
| - rc = UINT64_MAX; |
| + rc = ~0ull; |
| |
| return rc; |
| } |
| @@ -1903,7 +1124,6 @@ static void uv__get_cgroup1_memory_limits(char buf[static 1024], uint64_t* high, |
| char filename[4097]; |
| char* p; |
| int n; |
| - uint64_t cgroup1_max; |
| |
| /* Find out where the controller is mounted. */ |
| p = uv__cgroup1_find_memory_controller(buf, &n); |
| @@ -1920,22 +1140,12 @@ static void uv__get_cgroup1_memory_limits(char buf[static 1024], uint64_t* high, |
| * as indicated by uv__read_uint64 returning 0. |
| */ |
| if (*high != 0 && *max != 0) |
| - goto update_limits; |
| + return; |
| } |
| |
| /* Fall back to the limits of the global memory controller. */ |
| *high = uv__read_uint64("/sys/fs/cgroup/memory/memory.soft_limit_in_bytes"); |
| *max = uv__read_uint64("/sys/fs/cgroup/memory/memory.limit_in_bytes"); |
| - |
| - /* uv__read_uint64 detects cgroup2's "max", so we need to separately detect |
| - * cgroup1's maximum value (which is derived from LONG_MAX and PAGE_SIZE). |
| - */ |
| -update_limits: |
| - cgroup1_max = LONG_MAX & ~(sysconf(_SC_PAGESIZE) - 1); |
| - if (*high == cgroup1_max) |
| - *high = UINT64_MAX; |
| - if (*max == cgroup1_max) |
| - *max = UINT64_MAX; |
| } |
| |
| static void uv__get_cgroup2_memory_limits(char buf[static 1024], uint64_t* high, |
| diff --git a/deps/uv/src/unix/os390.c b/deps/uv/src/unix/os390.c |
| index a87c2d77faf..3954b2c2753 100644 |
| --- a/deps/uv/src/unix/os390.c |
| +++ b/deps/uv/src/unix/os390.c |
| @@ -808,7 +808,6 @@ static int os390_message_queue_handler(uv__os390_epoll* ep) { |
| |
| void uv__io_poll(uv_loop_t* loop, int timeout) { |
| static const int max_safe_timeout = 1789569; |
| - uv__loop_internal_fields_t* lfields; |
| struct epoll_event events[1024]; |
| struct epoll_event* pe; |
| struct epoll_event e; |
| @@ -831,8 +830,6 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| return; |
| } |
| |
| - lfields = uv__get_internal_fields(loop); |
| - |
| while (!QUEUE_EMPTY(&loop->watcher_queue)) { |
| uv_stream_t* stream; |
| |
| @@ -880,7 +877,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| int nevents = 0; |
| have_signals = 0; |
| |
| - if (lfields->flags & UV_METRICS_IDLE_TIME) { |
| + if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) { |
| reset_timeout = 1; |
| user_timeout = timeout; |
| timeout = 0; |
| @@ -899,12 +896,6 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| if (sizeof(int32_t) == sizeof(long) && timeout >= max_safe_timeout) |
| timeout = max_safe_timeout; |
| |
| - /* Store the current timeout in a location that's globally accessible so |
| - * other locations like uv__work_done() can determine whether the queue |
| - * of events in the callback were waiting when poll was called. |
| - */ |
| - lfields->current_timeout = timeout; |
| - |
| nfds = epoll_wait(loop->ep, events, |
| ARRAY_SIZE(events), timeout); |
| |
| diff --git a/deps/uv/src/unix/posix-poll.c b/deps/uv/src/unix/posix-poll.c |
| index 7e7de86845d..711780ece8d 100644 |
| --- a/deps/uv/src/unix/posix-poll.c |
| +++ b/deps/uv/src/unix/posix-poll.c |
| @@ -132,7 +132,6 @@ static void uv__pollfds_del(uv_loop_t* loop, int fd) { |
| |
| |
| void uv__io_poll(uv_loop_t* loop, int timeout) { |
| - uv__loop_internal_fields_t* lfields; |
| sigset_t* pset; |
| sigset_t set; |
| uint64_t time_base; |
| @@ -153,8 +152,6 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| return; |
| } |
| |
| - lfields = uv__get_internal_fields(loop); |
| - |
| /* Take queued watchers and add their fds to our poll fds array. */ |
| while (!QUEUE_EMPTY(&loop->watcher_queue)) { |
| q = QUEUE_HEAD(&loop->watcher_queue); |
| @@ -182,7 +179,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| assert(timeout >= -1); |
| time_base = loop->time; |
| |
| - if (lfields->flags & UV_METRICS_IDLE_TIME) { |
| + if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) { |
| reset_timeout = 1; |
| user_timeout = timeout; |
| timeout = 0; |
| @@ -201,12 +198,6 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { |
| if (timeout != 0) |
| uv__metrics_set_provider_entry_time(loop); |
| |
| - /* Store the current timeout in a location that's globally accessible so |
| - * other locations like uv__work_done() can determine whether the queue |
| - * of events in the callback were waiting when poll was called. |
| - */ |
| - lfields->current_timeout = timeout; |
| - |
| if (pset != NULL) |
| if (pthread_sigmask(SIG_BLOCK, pset, NULL)) |
| abort(); |
| diff --git a/deps/uv/src/uv-common.h b/deps/uv/src/uv-common.h |
| index decde5362c8..2720121addc 100644 |
| --- a/deps/uv/src/uv-common.h |
| +++ b/deps/uv/src/uv-common.h |
| @@ -396,37 +396,9 @@ struct uv__loop_metrics_s { |
| void uv__metrics_update_idle_time(uv_loop_t* loop); |
| void uv__metrics_set_provider_entry_time(uv_loop_t* loop); |
| |
| -#ifdef __linux__ |
| -struct uv__iou { |
| - uint32_t* sqhead; |
| - uint32_t* sqtail; |
| - uint32_t* sqarray; |
| - uint32_t sqmask; |
| - uint32_t* sqflags; |
| - uint32_t* cqhead; |
| - uint32_t* cqtail; |
| - uint32_t cqmask; |
| - void* sq; /* pointer to munmap() on event loop teardown */ |
| - void* cqe; /* pointer to array of struct uv__io_uring_cqe */ |
| - void* sqe; /* pointer to array of struct uv__io_uring_sqe */ |
| - size_t sqlen; |
| - size_t cqlen; |
| - size_t maxlen; |
| - size_t sqelen; |
| - int ringfd; |
| - uint32_t in_flight; |
| -}; |
| -#endif /* __linux__ */ |
| - |
| struct uv__loop_internal_fields_s { |
| unsigned int flags; |
| uv__loop_metrics_t loop_metrics; |
| - int current_timeout; |
| -#ifdef __linux__ |
| - struct uv__iou ctl; |
| - struct uv__iou iou; |
| - void* inv; /* used by uv__platform_invalidate_fd() */ |
| -#endif /* __linux__ */ |
| }; |
| |
| #endif /* UV_COMMON_H_ */ |
| diff --git a/deps/uv/src/win/core.c b/deps/uv/src/win/core.c |
| index 9a3be58849a..e4041ec86a6 100644 |
| --- a/deps/uv/src/win/core.c |
| +++ b/deps/uv/src/win/core.c |
| @@ -424,7 +424,6 @@ int uv_backend_timeout(const uv_loop_t* loop) { |
| |
| |
| static void uv__poll_wine(uv_loop_t* loop, DWORD timeout) { |
| - uv__loop_internal_fields_t* lfields; |
| DWORD bytes; |
| ULONG_PTR key; |
| OVERLAPPED* overlapped; |
| @@ -434,10 +433,9 @@ static void uv__poll_wine(uv_loop_t* loop, DWORD timeout) { |
| uint64_t user_timeout; |
| int reset_timeout; |
| |
| - lfields = uv__get_internal_fields(loop); |
| timeout_time = loop->time + timeout; |
| |
| - if (lfields->flags & UV_METRICS_IDLE_TIME) { |
| + if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) { |
| reset_timeout = 1; |
| user_timeout = timeout; |
| timeout = 0; |
| @@ -452,12 +450,6 @@ static void uv__poll_wine(uv_loop_t* loop, DWORD timeout) { |
| if (timeout != 0) |
| uv__metrics_set_provider_entry_time(loop); |
| |
| - /* Store the current timeout in a location that's globally accessible so |
| - * other locations like uv__work_done() can determine whether the queue |
| - * of events in the callback were waiting when poll was called. |
| - */ |
| - lfields->current_timeout = timeout; |
| - |
| GetQueuedCompletionStatus(loop->iocp, |
| &bytes, |
| &key, |
| @@ -515,7 +507,6 @@ static void uv__poll_wine(uv_loop_t* loop, DWORD timeout) { |
| |
| |
| static void uv__poll(uv_loop_t* loop, DWORD timeout) { |
| - uv__loop_internal_fields_t* lfields; |
| BOOL success; |
| uv_req_t* req; |
| OVERLAPPED_ENTRY overlappeds[128]; |
| @@ -527,10 +518,9 @@ static void uv__poll(uv_loop_t* loop, DWORD timeout) { |
| uint64_t actual_timeout; |
| int reset_timeout; |
| |
| - lfields = uv__get_internal_fields(loop); |
| timeout_time = loop->time + timeout; |
| |
| - if (lfields->flags & UV_METRICS_IDLE_TIME) { |
| + if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) { |
| reset_timeout = 1; |
| user_timeout = timeout; |
| timeout = 0; |
| @@ -547,12 +537,6 @@ static void uv__poll(uv_loop_t* loop, DWORD timeout) { |
| if (timeout != 0) |
| uv__metrics_set_provider_entry_time(loop); |
| |
| - /* Store the current timeout in a location that's globally accessible so |
| - * other locations like uv__work_done() can determine whether the queue |
| - * of events in the callback were waiting when poll was called. |
| - */ |
| - lfields->current_timeout = timeout; |
| - |
| success = pGetQueuedCompletionStatusEx(loop->iocp, |
| overlappeds, |
| ARRAY_SIZE(overlappeds), |