Karl Skomski <karl@skomski.com>
Jeremy Whitlock <jwhitlock@apache.org>
Willem Thiart <himself@willemthiart.com>
+Ben Trask <bentrask@comcast.net>
+Jianghua Yang <jianghua.yjh@alibaba-inc.com>
+Colin Snover <github.com@zetafleet.com>
+Sakthipriyan Vairamani <thechargingvolcano@gmail.com>
+Eli Skeggs <skeggse@gmail.com>
additional guidelines, are enumerated below.
* Code that is specific to unix-y platforms should be placed in `src/unix`, and
- declarations go into `src/uv-unix.h`.
+ declarations go into `include/uv-unix.h`.
* Source code that is Windows-specific goes into `src/win`, and related
publicly exported types, functions and macro declarations should generally
+2015.09.12, Version 1.7.4 (Stable), a7ad4f52189d89cfcba35f78bfc5ff3b1f4105c4
+
+Changes since version 1.7.3:
+
+* doc: uv_read_start and uv_read_cb clarifications (Ben Trask)
+
+* freebsd: obtain true uptime through clock_gettime() (Jianghua Yang)
+
+* win, tty: do not convert \r to \r\n (Colin Snover)
+
+* build,gyp: add DragonFly to the list of OSes (Michael Neumann)
+
+* fs: fix bug in sendfile for DragonFly (Michael Neumann)
+
+* doc: add uv_dlsym() return type (Brian White)
+
+* tests: fix fs tests run w/o full getdents support (Jeremy Whitlock)
+
+* doc: fix typo (Devchandra Meetei Leishangthem)
+
+* doc: fix uv-unix.h location (Sakthipriyan Vairamani)
+
+* unix: fix error check when closing process pipe fd (Ben Noordhuis)
+
+* test,freebsd: fix ipc_listen_xx_write tests (Santiago Gimeno)
+
+* win: fix unsavory rwlock fallback implementation (Bert Belder)
+
+* doc: clarify repeat timer behavior (Eli Skeggs)
+
+
2015.08.28, Version 1.7.3 (Stable), 93877b11c8b86e0a6befcda83a54555c1e36e4f0
Changes since version 1.7.2:
-version: v1.7.3.build{build}
+version: v1.7.4.build{build}
install:
- cinst -y nsis
}]
]
}],
- ['OS in "freebsd linux openbsd solaris android"', {
+ ['OS in "freebsd dragonflybsd linux openbsd solaris android"', {
'cflags': [ '-Wall' ],
'cflags_cc': [ '-fno-rtti', '-fno-exceptions' ],
'target_conditions': [
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
AC_PREREQ(2.57)
-AC_INIT([libuv], [1.7.3], [https://github.com/libuv/libuv/issues])
+AC_INIT([libuv], [1.7.4], [https://github.com/libuv/libuv/issues])
AC_CONFIG_MACRO_DIR([m4])
m4_include([m4/libuv-extra-automake-flags.m4])
m4_include([m4/as_case.m4])
Close the shared library.
-.. c:function:: uv_dlsym(uv_lib_t* lib, const char* name, void** ptr)
+.. c:function:: int uv_dlsym(uv_lib_t* lib, const char* name, void** ptr)
Retrieves a data pointer from a dynamic library. It is legal for a symbol
to map to NULL. Returns 0 on success and -1 if the symbol was not found.
Public members
^^^^^^^^^^^^^^
-.. c:member:: void* uv_request_t.data
+.. c:member:: void* uv_req_t.data
Space for user-defined arbitrary data. libuv does not use this field.
Callback called when data was read on a stream.
- `nread` is > 0 if there is data available, 0 if libuv is done reading for
- now, or < 0 on error.
+ `nread` is > 0 if there is data available or < 0 on error. When we've
+ reached EOF, `nread` will be set to ``UV_EOF``. When `nread` < 0,
+ the `buf` parameter might not point to a valid buffer; in that case
+ `buf.len` and `buf.base` are both set to 0.
+
+ .. note::
+ `nread` might be 0, which does *not* indicate an error or EOF. This
+ is equivalent to ``EAGAIN`` or ``EWOULDBLOCK`` under ``read(2)``.
The callee is responsible for stopping closing the stream when an error happens
by calling :c:func:`uv_read_stop` or :c:func:`uv_close`. Trying to read
.. c:function:: int uv_read_start(uv_stream_t* stream, uv_alloc_cb alloc_cb, uv_read_cb read_cb)
- Read data from an incoming stream. The callback will be made several
- times until there is no more data to read or :c:func:`uv_read_stop` is called.
- When we've reached EOF `nread` will be set to ``UV_EOF``.
-
- When `nread` < 0, the `buf` parameter might not point to a valid buffer;
- in that case `buf.len` and `buf.base` are both set to 0.
-
- .. note::
- `nread` might also be 0, which does *not* indicate an error or EOF, it happens when
- libuv requested a buffer through the alloc callback but then decided that it didn't
- need that buffer.
+ Read data from an incoming stream. The :c:type:`uv_read_cb` callback will
+ be made several times until there is no more data to read or
+ :c:func:`uv_read_stop` is called.
.. c:function:: int uv_read_stop(uv_stream_t*)
.. c:function:: void uv_timer_set_repeat(uv_timer_t* handle, uint64_t repeat)
- Set the repeat value in milliseconds.
+ Set the repeat interval value in milliseconds. The timer will be scheduled
+ to run on the given interval, regardless of the callback execution
+ duration, and will follow normal timer semantics in the case of a
+ time-slice overrun.
+
+ For example, if a 50ms repeating timer first runs for 17ms, it will be
+ scheduled to run again 33ms later. If other tasks consume more than the
+ 33ms following the first timer callback, then the callback will run as soon
+ as possible.
.. note::
If the repeat value is set from a timer callback it does not immediately take effect.
#define UV_VERSION_MAJOR 1
#define UV_VERSION_MINOR 7
-#define UV_VERSION_PATCH 3
+#define UV_VERSION_PATCH 4
#define UV_VERSION_IS_RELEASE 1
#define UV_VERSION_SUFFIX ""
/* windows.h. */
SRWLOCK srwlock_;
struct {
- uv_mutex_t read_mutex_;
- uv_mutex_t write_mutex_;
+ union {
+ CRITICAL_SECTION cs;
+ /* TODO: remove me in v2.x. */
+ uv_mutex_t unused;
+ } read_lock_;
+ union {
+ HANDLE sem;
+ /* TODO: remove me in v2.x. */
+ uv_mutex_t unused;
+ } write_lock_;
unsigned int num_readers_;
} fallback_;
} uv_rwlock_t;
int uv_uptime(double* uptime) {
- time_t now;
- struct timeval info;
- size_t size = sizeof(info);
- static int which[] = {CTL_KERN, KERN_BOOTTIME};
-
- if (sysctl(which, 2, &info, &size, NULL, 0))
+ int r;
+ struct timespec sp;
+ r = clock_gettime(CLOCK_MONOTONIC, &sp);
+ if (r)
return -errno;
- now = time(NULL);
-
- *uptime = (double)(now - info.tv_sec);
+ *uptime = sp.tv_sec;
return 0;
}
r = sendfile(in_fd, out_fd, req->off, &len, NULL, 0);
#endif
- if (r != -1 || len != 0) {
+ /*
+ * The man page for sendfile(2) on DragonFly states that `len` contains
+ * a meaningful value ONLY in case of EAGAIN and EINTR.
+ * Nothing is said about it's value in case of other errors, so better
+ * not depend on the potential wrong assumption that is was not modified
+ * by the syscall.
+ */
+ if (r == 0 || ((errno == EAGAIN || errno == EINTR) && len != 0)) {
req->off += len;
return (ssize_t) len;
}
int pipefds[2],
int writable) {
int flags;
+ int err;
if (!(container->flags & UV_CREATE_PIPE) || pipefds[0] < 0)
return 0;
- if (uv__close(pipefds[1]))
- if (errno != EINTR && errno != EINPROGRESS)
- abort();
+ err = uv__close(pipefds[1]);
+ if (err != 0 && err != -EINPROGRESS)
+ abort();
pipefds[1] = -1;
uv__nonblock(pipefds[0], 1);
static int uv__rwlock_fallback_init(uv_rwlock_t* rwlock) {
- int err;
-
- err = uv_mutex_init(&rwlock->fallback_.read_mutex_);
- if (err)
- return err;
+ /* Initialize the semaphore that acts as the write lock. */
+ HANDLE handle = CreateSemaphoreW(NULL, 1, 1, NULL);
+ if (handle == NULL)
+ return uv_translate_sys_error(GetLastError());
+ rwlock->fallback_.write_lock_.sem = handle;
- err = uv_mutex_init(&rwlock->fallback_.write_mutex_);
- if (err) {
- uv_mutex_destroy(&rwlock->fallback_.read_mutex_);
- return err;
- }
+ /* Initialize the critical section protecting the reader count. */
+ InitializeCriticalSection(&rwlock->fallback_.read_lock_.cs);
+ /* Initialize the reader count. */
rwlock->fallback_.num_readers_ = 0;
return 0;
static void uv__rwlock_fallback_destroy(uv_rwlock_t* rwlock) {
- uv_mutex_destroy(&rwlock->fallback_.read_mutex_);
- uv_mutex_destroy(&rwlock->fallback_.write_mutex_);
+ DeleteCriticalSection(&rwlock->fallback_.read_lock_.cs);
+ CloseHandle(rwlock->fallback_.write_lock_.sem);
}
static void uv__rwlock_fallback_rdlock(uv_rwlock_t* rwlock) {
- uv_mutex_lock(&rwlock->fallback_.read_mutex_);
-
- if (++rwlock->fallback_.num_readers_ == 1)
- uv_mutex_lock(&rwlock->fallback_.write_mutex_);
+ /* Acquire the lock that protects the reader count. */
+ EnterCriticalSection(&rwlock->fallback_.read_lock_.cs);
+
+ /* Increase the reader count, and lock for write if this is the first
+ * reader.
+ */
+ if (++rwlock->fallback_.num_readers_ == 1) {
+ DWORD r = WaitForSingleObject(rwlock->fallback_.write_lock_.sem, INFINITE);
+ if (r != WAIT_OBJECT_0)
+ uv_fatal_error(GetLastError(), "WaitForSingleObject");
+ }
- uv_mutex_unlock(&rwlock->fallback_.read_mutex_);
+ /* Release the lock that protects the reader count. */
+ LeaveCriticalSection(&rwlock->fallback_.read_lock_.cs);
}
static int uv__rwlock_fallback_tryrdlock(uv_rwlock_t* rwlock) {
int err;
- err = uv_mutex_trylock(&rwlock->fallback_.read_mutex_);
- if (err)
- goto out;
+ if (!TryEnterCriticalSection(&rwlock->fallback_.read_lock_.cs))
+ return UV_EAGAIN;
err = 0;
- if (rwlock->fallback_.num_readers_ == 0)
- err = uv_mutex_trylock(&rwlock->fallback_.write_mutex_);
-
- if (err == 0)
- rwlock->fallback_.num_readers_++;
-
- uv_mutex_unlock(&rwlock->fallback_.read_mutex_);
+ if (rwlock->fallback_.num_readers_ == 0) {
+ DWORD r = WaitForSingleObject(rwlock->fallback_.write_lock_.sem, 0);
+ if (r == WAIT_OBJECT_0)
+ rwlock->fallback_.num_readers_++;
+ else if (r == WAIT_TIMEOUT)
+ err = UV_EAGAIN;
+ else if (r == WAIT_FAILED)
+ err = uv_translate_sys_error(GetLastError());
+ else
+ err = UV_EIO;
+ }
-out:
+ LeaveCriticalSection(&rwlock->fallback_.read_lock_.cs);
return err;
}
static void uv__rwlock_fallback_rdunlock(uv_rwlock_t* rwlock) {
- uv_mutex_lock(&rwlock->fallback_.read_mutex_);
+ EnterCriticalSection(&rwlock->fallback_.read_lock_.cs);
- if (--rwlock->fallback_.num_readers_ == 0)
- uv_mutex_unlock(&rwlock->fallback_.write_mutex_);
+ if (--rwlock->fallback_.num_readers_ == 0) {
+ if (!ReleaseSemaphore(rwlock->fallback_.write_lock_.sem, 1, NULL))
+ uv_fatal_error(GetLastError(), "ReleaseSemaphore");
+ }
- uv_mutex_unlock(&rwlock->fallback_.read_mutex_);
+ LeaveCriticalSection(&rwlock->fallback_.read_lock_.cs);
}
static void uv__rwlock_fallback_wrlock(uv_rwlock_t* rwlock) {
- uv_mutex_lock(&rwlock->fallback_.write_mutex_);
+ DWORD r = WaitForSingleObject(rwlock->fallback_.write_lock_.sem, INFINITE);
+ if (r != WAIT_OBJECT_0)
+ uv_fatal_error(GetLastError(), "WaitForSingleObject");
}
static int uv__rwlock_fallback_trywrlock(uv_rwlock_t* rwlock) {
- return uv_mutex_trylock(&rwlock->fallback_.write_mutex_);
+ DWORD r = WaitForSingleObject(rwlock->fallback_.write_lock_.sem, 0);
+ if (r == WAIT_OBJECT_0)
+ return 0;
+ else if (r == WAIT_TIMEOUT)
+ return UV_EAGAIN;
+ else if (r == WAIT_FAILED)
+ return uv_translate_sys_error(GetLastError());
+ else
+ return UV_EIO;
}
static void uv__rwlock_fallback_wrunlock(uv_rwlock_t* rwlock) {
- uv_mutex_unlock(&rwlock->fallback_.write_mutex_);
+ if (!ReleaseSemaphore(rwlock->fallback_.write_lock_.sem, 1, NULL))
+ uv_fatal_error(GetLastError(), "ReleaseSemaphore");
}
} \
} while (0)
+#define ENSURE_BUFFER_SPACE(wchars_needed) \
+ if (wchars_needed > ARRAY_SIZE(utf16_buf) - utf16_buf_used) { \
+ FLUSH_TEXT(); \
+ }
+
/* Cache for fast access */
unsigned char utf8_bytes_left = handle->tty.wr.utf8_bytes_left;
unsigned int utf8_codepoint = handle->tty.wr.utf8_codepoint;
}
if (utf8_codepoint == 0x0a || utf8_codepoint == 0x0d) {
- /* EOL conversion - emit \r\n, when we see either \r or \n. */
- /* If a \n immediately follows a \r or vice versa, ignore it. */
- if (previous_eol == 0 || utf8_codepoint == previous_eol) {
- /* If there's no room in the utf16 buf, flush it first. */
- if (2 > ARRAY_SIZE(utf16_buf) - utf16_buf_used) {
- uv_tty_emit_text(handle, utf16_buf, utf16_buf_used, error);
- utf16_buf_used = 0;
- }
+ /* EOL conversion - emit \r\n when we see \n. */
+ if (utf8_codepoint == 0x0a && previous_eol != 0x0d) {
+ /* \n was not preceded by \r; print \r\n. */
+ ENSURE_BUFFER_SPACE(2);
utf16_buf[utf16_buf_used++] = L'\r';
utf16_buf[utf16_buf_used++] = L'\n';
- previous_eol = (char) utf8_codepoint;
+ } else if (utf8_codepoint == 0x0d && previous_eol == 0x0a) {
+ /* \n was followed by \r; do not print the \r, since */
+ /* the source was either \r\n\r (so the second \r is */
+ /* redundant) or was \n\r (so the \n was processed */
+ /* by the last case and an \r automatically inserted). */
} else {
- /* Ignore this newline, but don't ignore later ones. */
- previous_eol = 0;
+ /* \r without \n; print \r as-is. */
+ ENSURE_BUFFER_SPACE(1);
+ utf16_buf[utf16_buf_used++] = (WCHAR) utf8_codepoint;
}
+ previous_eol = (char) utf8_codepoint;
+
} else if (utf8_codepoint <= 0xffff) {
/* Encode character into utf-16 buffer. */
-
- /* If there's no room in the utf16 buf, flush it first. */
- if (1 > ARRAY_SIZE(utf16_buf) - utf16_buf_used) {
- uv_tty_emit_text(handle, utf16_buf, utf16_buf_used, error);
- utf16_buf_used = 0;
- }
-
+ ENSURE_BUFFER_SPACE(1);
utf16_buf[utf16_buf_used++] = (WCHAR) utf8_codepoint;
previous_eol = 0;
}
}
+static void assert_is_file_type(uv_dirent_t dent) {
+#ifdef HAVE_DIRENT_TYPES
+ /*
+ * For Apple and Windows, we know getdents is expected to work but for other
+ * environments, the filesystem dictates whether or not getdents supports
+ * returning the file type.
+ *
+ * See:
+ * http://man7.org/linux/man-pages/man2/getdents.2.html
+ * https://github.com/libuv/libuv/issues/501
+ */
+ #if defined(__APPLE__) || defined(_WIN32)
+ ASSERT(dent.type == UV_DIRENT_FILE);
+ #else
+ ASSERT(dent.type == UV_DIRENT_FILE || dent.type == UV_DIRENT_UNKNOWN);
+ #endif
+#else
+ ASSERT(dent.type == UV_DIRENT_UNKNOWN);
+#endif
+}
+
+
static void scandir_cb(uv_fs_t* req) {
uv_dirent_t dent;
ASSERT(req == &scandir_req);
while (UV_EOF != uv_fs_scandir_next(req, &dent)) {
ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0);
-#ifdef HAVE_DIRENT_TYPES
- ASSERT(dent.type == UV_DIRENT_FILE);
-#else
- ASSERT(dent.type == UV_DIRENT_UNKNOWN);
-#endif
+ assert_is_file_type(dent);
}
scandir_cb_count++;
ASSERT(req->path);
ASSERT(scandir_req.ptr);
while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) {
ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0);
-#ifdef HAVE_DIRENT_TYPES
- ASSERT(dent.type == UV_DIRENT_FILE);
-#else
- ASSERT(dent.type == UV_DIRENT_UNKNOWN);
-#endif
+ assert_is_file_type(dent);
}
uv_fs_req_cleanup(&scandir_req);
ASSERT(!scandir_req.ptr);
r = uv_fs_symlink(NULL, &req, test_dir, "test_dir_symlink",
UV_FS_SYMLINK_JUNCTION, NULL);
+ fprintf(stderr, "r == %i\n", r);
ASSERT(r == 0);
ASSERT(req.result == 0);
uv_fs_req_cleanup(&req);
ASSERT(scandir_req.ptr);
while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) {
ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0);
-#ifdef HAVE_DIRENT_TYPES
- ASSERT(dent.type == UV_DIRENT_FILE);
-#else
- ASSERT(dent.type == UV_DIRENT_UNKNOWN);
-#endif
+ assert_is_file_type(dent);
}
uv_fs_req_cleanup(&scandir_req);
ASSERT(!scandir_req.ptr);
ASSERT(scandir_req.ptr);
while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) {
ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0);
-#ifdef HAVE_DIRENT_TYPES
- ASSERT(dent.type == UV_DIRENT_FILE);
-#else
- ASSERT(dent.type == UV_DIRENT_UNKNOWN);
-#endif
+ assert_is_file_type(dent);
}
uv_fs_req_cleanup(&scandir_req);
ASSERT(!scandir_req.ptr);
} tcp_conn;
#define CONN_COUNT 100
+#define BACKLOG 128
static void close_server_conn_cb(uv_handle_t* handle) {
r = uv_accept((uv_stream_t*)pipe, (uv_stream_t*)&tcp_server);
ASSERT(r == 0);
- r = uv_listen((uv_stream_t*)&tcp_server, 12, on_connection);
+ r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, on_connection);
ASSERT(r == 0);
tcp_server_listening = 1;
ASSERT(pending == UV_TCP);
r = uv_tcp_init(uv_default_loop(), &tcp_server);
ASSERT(r == 0);
-
+
r = uv_accept((uv_stream_t*)pipe, (uv_stream_t*)&tcp_server);
ASSERT(r == 0);
-
- r = uv_listen((uv_stream_t*)&tcp_server, 12, on_connection);
- ASSERT(r == 0);
+
+ r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, on_connection);
+ ASSERT(r == 0);
} else if (read_cb_called == 2) {
/* Accept the second TCP server, and start listening on it. */
ASSERT(pending == UV_TCP);
r = uv_tcp_init(uv_default_loop(), &tcp_server2);
ASSERT(r == 0);
-
+
r = uv_accept((uv_stream_t*)pipe, (uv_stream_t*)&tcp_server2);
ASSERT(r == 0);
-
- r = uv_listen((uv_stream_t*)&tcp_server2, 12, on_connection);
+
+ r = uv_listen((uv_stream_t*)&tcp_server2, BACKLOG, on_connection);
ASSERT(r == UV_EADDRINUSE);
uv_close((uv_handle_t*)&tcp_server, NULL);
ASSERT(r == 0);
if (!listen_after_write) {
- r = uv_listen((uv_stream_t*)&tcp_server, 12, ipc_on_connection);
+ r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, ipc_on_connection);
ASSERT(r == 0);
}
ASSERT(r == 0);
if (listen_after_write) {
- r = uv_listen((uv_stream_t*)&tcp_server, 12, ipc_on_connection);
+ r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, ipc_on_connection);
ASSERT(r == 0);
}
r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0);
ASSERT(r == 0);
- r = uv_listen((uv_stream_t*)&tcp_server, 12, ipc_on_connection_tcp_conn);
+ r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, ipc_on_connection_tcp_conn);
ASSERT(r == 0);
/* Make a connection to the server */
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
-
+
MAKE_VALGRIND_HAPPY();
return 0;
}
projects / platform / upstream / nodejs.git / commitdiff