Debug
Release
ipch
+*.mk
+*.Makefile
CSTDFLAG += -D_GNU_SOURCE
CPPFLAGS += -Isrc/ares/config_linux
LINKFLAGS+=-lrt
-OBJS += src/unix/linux.o
+OBJS += src/unix/linux/core.o src/unix/linux/inotify.o
endif
ifeq (FreeBSD,$(uname_S))
typedef void* uv_lib_t;
#define UV_DYNAMIC /* empty */
+#if __linux__
+# define UV_LOOP_PRIVATE_PLATFORM_FIELDS \
+ /* RB_HEAD(uv__inotify_watchers, uv_fs_event_s) */ \
+ struct uv__inotify_watchers { \
+ struct uv_fs_event_s* rbh_root; \
+ } inotify_watchers; \
+ ev_io inotify_read_watcher; \
+ int inotify_fd;
+#else
+# define UV_LOOP_PRIVATE_PLATFORM_FIELDS
+#endif
+
#define UV_LOOP_PRIVATE_FIELDS \
ares_channel channel; \
/* \
ev_timer timer; \
/* Poll result queue */ \
eio_channel uv_eio_channel; \
- struct ev_loop* ev;
+ struct ev_loop* ev; \
+ UV_LOOP_PRIVATE_PLATFORM_FIELDS
#define UV_REQ_BUFSML_SIZE (4)
/* UV_FS_EVENT_PRIVATE_FIELDS */
#if defined(__linux__)
-#define UV_FS_EVENT_PRIVATE_FIELDS \
- ev_io read_watcher; \
- uv_fs_event_cb cb; \
+#define UV_FS_EVENT_PRIVATE_FIELDS \
+ /* RB_ENTRY(fs_event_s) node; */ \
+ struct { \
+ struct uv_fs_event_s* rbe_left; \
+ struct uv_fs_event_s* rbe_right; \
+ struct uv_fs_event_s* rbe_parent; \
+ int rbe_color; \
+ } node; \
+ ev_io read_watcher; \
+ uv_fs_event_cb cb;
#elif (defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1060) \
|| defined(__FreeBSD__) \
#undef UV_FS_REQ_PRIVATE_FIELDS
#undef UV_WORK_PRIVATE_FIELDS
#undef UV_FS_EVENT_PRIVATE_FIELDS
+#undef UV_LOOP_PRIVATE_FIELDS
+#undef UV_LOOP_PRIVATE_PLATFORM_FIELDS
#ifdef __cplusplus
}
void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
uv_async_t* async;
- uv_timer_t* timer;
uv_stream_t* stream;
uv_process_t* process;
break;
case UV_TIMER:
- timer = (uv_timer_t*)handle;
- if (ev_is_active(&timer->timer_watcher)) {
- ev_ref(timer->loop->ev);
- }
- ev_timer_stop(timer->loop->ev, &timer->timer_watcher);
+ uv_timer_stop((uv_timer_t*)handle);
break;
case UV_PROCESS:
#endif
ev_set_userdata(loop->ev, loop);
eio_channel_init(&loop->uv_eio_channel, loop);
+ uv__loop_platform_init(loop);
return 0;
}
void uv_loop_delete(uv_loop_t* loop) {
uv_ares_destroy(loop, loop->channel);
ev_loop_destroy(loop->ev);
-
+ uv__loop_platform_delete(loop);
#ifndef NDEBUG
- memset(loop, 0, sizeof *loop);
+ memset(loop, -1, sizeof *loop);
#endif
-
if (loop == default_loop_ptr)
default_loop_ptr = NULL;
else
}
+static int uv__timer_active(const uv_timer_t* timer) {
+ return timer->flags & UV_TIMER_ACTIVE;
+}
+
+
+static int uv__timer_repeating(const uv_timer_t* timer) {
+ return timer->flags & UV_TIMER_REPEAT;
+}
+
+
static void uv__timer_cb(EV_P_ ev_timer* w, int revents) {
uv_timer_t* timer = container_of(w, uv_timer_t, timer_watcher);
- if (!ev_is_active(w)) {
+ assert(uv__timer_active(timer));
+
+ if (!uv__timer_repeating(timer)) {
+ timer->flags &= ~UV_TIMER_ACTIVE;
ev_ref(EV_A);
}
int uv_timer_start(uv_timer_t* timer, uv_timer_cb cb, int64_t timeout,
int64_t repeat) {
- if (ev_is_active(&timer->timer_watcher)) {
+ if (uv__timer_active(timer)) {
return -1;
}
timer->timer_cb = cb;
+ timer->flags |= UV_TIMER_ACTIVE;
+
+ if (repeat)
+ timer->flags |= UV_TIMER_REPEAT;
+ else
+ timer->flags &= ~UV_TIMER_REPEAT;
+
ev_timer_set(&timer->timer_watcher, timeout / 1000.0, repeat / 1000.0);
ev_timer_start(timer->loop->ev, &timer->timer_watcher);
ev_unref(timer->loop->ev);
+
return 0;
}
int uv_timer_stop(uv_timer_t* timer) {
- if (ev_is_active(&timer->timer_watcher)) {
+ if (uv__timer_active(timer)) {
ev_ref(timer->loop->ev);
}
+ timer->flags &= ~(UV_TIMER_ACTIVE | UV_TIMER_REPEAT);
ev_timer_stop(timer->loop->ev, &timer->timer_watcher);
+
return 0;
}
int uv_timer_again(uv_timer_t* timer) {
- if (!ev_is_active(&timer->timer_watcher)) {
+ if (!uv__timer_active(timer)) {
uv__set_sys_error(timer->loop, EINVAL);
return -1;
}
+ assert(uv__timer_repeating(timer));
ev_timer_again(timer->loop->ev, &timer->timer_watcher);
return 0;
}
+
void uv_timer_set_repeat(uv_timer_t* timer, int64_t repeat) {
assert(timer->type == UV_TIMER);
timer->timer_watcher.repeat = repeat / 1000.0;
+
+ if (repeat)
+ timer->flags |= UV_TIMER_REPEAT;
+ else
+ timer->flags &= ~UV_TIMER_REPEAT;
}
+
int64_t uv_timer_get_repeat(uv_timer_t* timer) {
assert(timer->type == UV_TIMER);
return (int64_t)(1000 * timer->timer_watcher.repeat);
int uv_exepath(char* buffer, size_t* size) {
uint32_t usize;
int result;
- char* path;
char* fullpath;
if (!buffer || !size) {
result = _NSGetExecutablePath(buffer, &usize);
if (result) return result;
- path = (char*)malloc(2 * PATH_MAX);
- fullpath = realpath(buffer, path);
+ fullpath = realpath(buffer, NULL);
if (fullpath == NULL) {
- free(path);
return -1;
}
ev_unref (EV_P)
{
--activecnt;
+ if (activecnt < 0) abort();
}
void
#undef NANOSEC
#define NANOSEC 1000000000
+#ifndef CPUSTATES
+# define CPUSTATES 5U
+#endif
+#ifndef CP_USER
+# define CP_USER 0
+# define CP_NICE 1
+# define CP_SYS 2
+# define CP_IDLE 3
+# define CP_INTR 4
+#endif
static char *process_title;
kinfo = kvm_getprocs(kd, KERN_PROC_PID, pid, &nprocs);
if (kinfo == NULL) goto error;
+#ifdef __DragonFly__
+ *rss = kinfo->kp_vm_rssize * page_size;
+#else
*rss = kinfo->ki_rssize * page_size;
+#endif
kvm_close(kd);
}
/* kern.cp_times on FreeBSD i386 gives an array up to maxcpus instead of ncpu */
size = sizeof(maxcpus);
+#ifdef __DragonFly__
+ if (sysctlbyname("hw.ncpu", &maxcpus, &size, NULL, 0) < 0) {
+ free(*cpu_infos);
+ return uv__new_sys_error(errno);
+ }
+#else
if (sysctlbyname("kern.smp.maxcpus", &maxcpus, &size, NULL, 0) < 0) {
free(*cpu_infos);
return uv__new_sys_error(errno);
}
+#endif
size = maxcpus * CPUSTATES * sizeof(long);
UV_READABLE = 0x20, /* The stream is readable */
UV_WRITABLE = 0x40, /* The stream is writable */
UV_TCP_NODELAY = 0x080, /* Disable Nagle. */
- UV_TCP_KEEPALIVE = 0x100 /* Turn on keep-alive. */
+ UV_TCP_KEEPALIVE = 0x100, /* Turn on keep-alive. */
+ UV_TIMER_ACTIVE = 0x080,
+ UV_TIMER_REPEAT = 0x100
};
/* core */
int uv__make_socketpair(int fds[2], int flags);
int uv__make_pipe(int fds[2], int flags);
+#if __linux__
+void uv__inotify_loop_init(uv_loop_t* loop);
+void uv__inotify_loop_delete(uv_loop_t* loop);
+# define uv__loop_platform_init(loop) uv__inotify_loop_init(loop)
+# define uv__loop_platform_delete(loop) uv__inotify_loop_delete(loop)
+#else
+# define uv__loop_platform_init(loop)
+# define uv__loop_platform_delete(loop)
+#endif
+
#endif /* UV_UNIX_INTERNAL_H_ */
*/
#include "uv.h"
-#include "internal.h"
+#include "../internal.h"
#include <stdint.h>
#include <stdio.h>
#include <assert.h>
#include <errno.h>
-#include <ifaddrs.h>
#include <net/if.h>
#include <sys/param.h>
#include <sys/sysinfo.h>
#include <fcntl.h>
#include <time.h>
-#undef NANOSEC
-#define NANOSEC 1000000000
-
-#undef HAVE_INOTIFY_INIT
-#undef HAVE_INOTIFY_INIT1
-#undef HAVE_INOTIFY_ADD_WATCH
-#undef HAVE_INOTIFY_RM_WATCH
-
-#if __NR_inotify_init
-# define HAVE_INOTIFY_INIT 1
-#endif
-#if __NR_inotify_init1
-# define HAVE_INOTIFY_INIT1 1
+#define HAVE_IFADDRS_H 1
+#ifdef __UCLIBC__
+# if __UCLIBC_MAJOR__ < 0 || __UCLIBC_MINOR__ < 9 || __UCLIBC_SUBLEVEL__ < 32
+# undef HAVE_IFADDRS_H
+# endif
#endif
-#if __NR_inotify_add_watch
-# define HAVE_INOTIFY_ADD_WATCH 1
+#ifdef HAVE_IFADDRS_H
+# include <ifaddrs.h>
#endif
-#if __NR_inotify_rm_watch
-# define HAVE_INOTIFY_RM_WATCH 1
-#endif
-
-#if HAVE_INOTIFY_INIT || HAVE_INOTIFY_INIT1
-# undef IN_ACCESS
-# undef IN_MODIFY
-# undef IN_ATTRIB
-# undef IN_CLOSE_WRITE
-# undef IN_CLOSE_NOWRITE
-# undef IN_OPEN
-# undef IN_MOVED_FROM
-# undef IN_MOVED_TO
-# undef IN_CREATE
-# undef IN_DELETE
-# undef IN_DELETE_SELF
-# undef IN_MOVE_SELF
-# define IN_ACCESS 0x001
-# define IN_MODIFY 0x002
-# define IN_ATTRIB 0x004
-# define IN_CLOSE_WRITE 0x008
-# define IN_CLOSE_NOWRITE 0x010
-# define IN_OPEN 0x020
-# define IN_MOVED_FROM 0x040
-# define IN_MOVED_TO 0x080
-# define IN_CREATE 0x100
-# define IN_DELETE 0x200
-# define IN_DELETE_SELF 0x400
-# define IN_MOVE_SELF 0x800
-struct inotify_event {
- int32_t wd;
- uint32_t mask;
- uint32_t cookie;
- uint32_t len;
- /* char name[0]; */
-};
-#endif /* HAVE_INOTIFY_INIT || HAVE_INOTIFY_INIT1 */
-
-#undef IN_CLOEXEC
-#undef IN_NONBLOCK
-
-#if HAVE_INOTIFY_INIT1
-# define IN_CLOEXEC O_CLOEXEC
-# define IN_NONBLOCK O_NONBLOCK
-#endif /* HAVE_INOTIFY_INIT1 */
-
-#if HAVE_INOTIFY_INIT
-inline static int inotify_init(void) {
- return syscall(__NR_inotify_init);
-}
-#endif /* HAVE_INOTIFY_INIT */
-
-#if HAVE_INOTIFY_INIT1
-inline static int inotify_init1(int flags) {
- return syscall(__NR_inotify_init1, flags);
-}
-#endif /* HAVE_INOTIFY_INIT1 */
-
-#if HAVE_INOTIFY_ADD_WATCH
-inline static int inotify_add_watch(int fd, const char* path, uint32_t mask) {
- return syscall(__NR_inotify_add_watch, fd, path, mask);
-}
-#endif /* HAVE_INOTIFY_ADD_WATCH */
-
-#if HAVE_INOTIFY_RM_WATCH
-inline static int inotify_rm_watch(int fd, uint32_t wd) {
- return syscall(__NR_inotify_rm_watch, fd, wd);
-}
-#endif /* HAVE_INOTIFY_RM_WATCH */
+#undef NANOSEC
+#define NANOSEC 1000000000
static char buf[MAXPATHLEN + 1];
} process_title;
-/* Don't look aghast, this is exactly how glibc's basename() works. */
-static char* basename_r(const char* path) {
- char* s = strrchr(path, '/');
- return s ? (s + 1) : (char*)path;
-}
-
-
/*
* There's probably some way to get time from Linux than gettimeofday(). What
* it is, I don't know.
int uv_exepath(char* buffer, size_t* size) {
+ ssize_t n;
+
if (!buffer || !size) {
return -1;
}
- *size = readlink("/proc/self/exe", buffer, *size - 1);
- if (*size <= 0) return -1;
- buffer[*size] = '\0';
+ n = readlink("/proc/self/exe", buffer, *size - 1);
+ if (n <= 0) return -1;
+ buffer[n] = '\0';
+ *size = n;
+
return 0;
}
uv_err_t uv_interface_addresses(uv_interface_address_t** addresses,
int* count) {
+#ifndef HAVE_IFADDRS_H
+ return uv__new_artificial_error(UV_ENOSYS);
+#else
struct ifaddrs *addrs, *ent;
char ip[INET6_ADDRSTRLEN];
uv_interface_address_t* address;
freeifaddrs(addrs);
return uv_ok_;
+#endif
}
free(addresses);
}
-
-#if HAVE_INOTIFY_INIT || HAVE_INOTIFY_INIT1
-
-static int new_inotify_fd(void) {
-#if HAVE_INOTIFY_INIT1
- return inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
-#else
- int fd;
-
- if ((fd = inotify_init()) == -1)
- return -1;
-
- if (uv__cloexec(fd, 1) || uv__nonblock(fd, 1)) {
- SAVE_ERRNO(uv__close(fd));
- fd = -1;
- }
-
- return fd;
-#endif
-}
-
-
-static void uv__inotify_read(EV_P_ ev_io* w, int revents) {
- struct inotify_event* e;
- uv_fs_event_t* handle;
- const char* filename;
- ssize_t size;
- int events;
- char *p;
- /* needs to be large enough for sizeof(inotify_event) + strlen(filename) */
- char buf[4096];
-
- handle = container_of(w, uv_fs_event_t, read_watcher);
-
- do {
- do {
- size = read(handle->fd, buf, sizeof buf);
- }
- while (size == -1 && errno == EINTR);
-
- if (size == -1) {
- assert(errno == EAGAIN || errno == EWOULDBLOCK);
- break;
- }
-
- assert(size > 0); /* pre-2.6.21 thing, size=0 == read buffer too small */
-
- /* Now we have one or more inotify_event structs. */
- for (p = buf; p < buf + size; p += sizeof(*e) + e->len) {
- e = (void*)p;
-
- events = 0;
- if (e->mask & (IN_ATTRIB|IN_MODIFY))
- events |= UV_CHANGE;
- if (e->mask & ~(IN_ATTRIB|IN_MODIFY))
- events |= UV_RENAME;
-
- /* inotify does not return the filename when monitoring a single file
- * for modifications. Repurpose the filename for API compatibility.
- * I'm not convinced this is a good thing, maybe it should go.
- */
- filename = e->len ? (const char*) (e + 1) : basename_r(handle->filename);
-
- handle->cb(handle, filename, events, 0);
-
- if (handle->fd == -1)
- break;
- }
- }
- while (handle->fd != -1); /* handle might've been closed by callback */
-}
-
-
-int uv_fs_event_init(uv_loop_t* loop,
- uv_fs_event_t* handle,
- const char* filename,
- uv_fs_event_cb cb,
- int flags) {
- int events;
- int fd;
-
- loop->counters.fs_event_init++;
-
- /* We don't support any flags yet. */
- assert(!flags);
-
- /*
- * TODO share a single inotify fd across the event loop?
- * We'll run into fs.inotify.max_user_instances if we
- * keep creating new inotify fds.
- */
- if ((fd = new_inotify_fd()) == -1) {
- uv__set_sys_error(loop, errno);
- return -1;
- }
-
- events = IN_ATTRIB
- | IN_CREATE
- | IN_MODIFY
- | IN_DELETE
- | IN_DELETE_SELF
- | IN_MOVED_FROM
- | IN_MOVED_TO;
-
- if (inotify_add_watch(fd, filename, events) == -1) {
- uv__set_sys_error(loop, errno);
- uv__close(fd);
- return -1;
- }
-
- uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT);
- handle->filename = strdup(filename); /* this should go! */
- handle->cb = cb;
- handle->fd = fd;
-
- ev_io_init(&handle->read_watcher, uv__inotify_read, fd, EV_READ);
- ev_io_start(loop->ev, &handle->read_watcher);
- ev_unref(loop->ev);
-
- return 0;
-}
-
-
-void uv__fs_event_destroy(uv_fs_event_t* handle) {
- ev_ref(handle->loop->ev);
- ev_io_stop(handle->loop->ev, &handle->read_watcher);
- uv__close(handle->fd);
- handle->fd = -1;
- free(handle->filename);
- handle->filename = NULL;
-}
-
-#else /* !HAVE_INOTIFY_INIT || HAVE_INOTIFY_INIT1 */
-
-int uv_fs_event_init(uv_loop_t* loop,
- uv_fs_event_t* handle,
- const char* filename,
- uv_fs_event_cb cb,
- int flags) {
- loop->counters.fs_event_init++;
- uv__set_sys_error(loop, ENOSYS);
- return -1;
-}
-
-
-void uv__fs_event_destroy(uv_fs_event_t* handle) {
- UNREACHABLE();
-}
-
-#endif /* HAVE_INOTIFY_INIT || HAVE_INOTIFY_INIT1 */
--- /dev/null
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include "uv.h"
+#include "tree.h"
+#include "../internal.h"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <errno.h>
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#undef HAVE_INOTIFY_INIT
+#undef HAVE_INOTIFY_INIT1
+#undef HAVE_INOTIFY_ADD_WATCH
+#undef HAVE_INOTIFY_RM_WATCH
+
+#if __NR_inotify_init
+# define HAVE_INOTIFY_INIT 1
+#endif
+#if __NR_inotify_init1
+# define HAVE_INOTIFY_INIT1 1
+#endif
+#if __NR_inotify_add_watch
+# define HAVE_INOTIFY_ADD_WATCH 1
+#endif
+#if __NR_inotify_rm_watch
+# define HAVE_INOTIFY_RM_WATCH 1
+#endif
+
+#if HAVE_INOTIFY_INIT || HAVE_INOTIFY_INIT1
+# undef IN_ACCESS
+# undef IN_MODIFY
+# undef IN_ATTRIB
+# undef IN_CLOSE_WRITE
+# undef IN_CLOSE_NOWRITE
+# undef IN_OPEN
+# undef IN_MOVED_FROM
+# undef IN_MOVED_TO
+# undef IN_CREATE
+# undef IN_DELETE
+# undef IN_DELETE_SELF
+# undef IN_MOVE_SELF
+# define IN_ACCESS 0x001
+# define IN_MODIFY 0x002
+# define IN_ATTRIB 0x004
+# define IN_CLOSE_WRITE 0x008
+# define IN_CLOSE_NOWRITE 0x010
+# define IN_OPEN 0x020
+# define IN_MOVED_FROM 0x040
+# define IN_MOVED_TO 0x080
+# define IN_CREATE 0x100
+# define IN_DELETE 0x200
+# define IN_DELETE_SELF 0x400
+# define IN_MOVE_SELF 0x800
+struct inotify_event {
+ int32_t wd;
+ uint32_t mask;
+ uint32_t cookie;
+ uint32_t len;
+ /* char name[0]; */
+};
+#endif /* HAVE_INOTIFY_INIT || HAVE_INOTIFY_INIT1 */
+
+#undef IN_CLOEXEC
+#undef IN_NONBLOCK
+
+#if HAVE_INOTIFY_INIT1
+# define IN_CLOEXEC O_CLOEXEC
+# define IN_NONBLOCK O_NONBLOCK
+#endif /* HAVE_INOTIFY_INIT1 */
+
+#if HAVE_INOTIFY_INIT
+inline static int inotify_init(void) {
+ return syscall(__NR_inotify_init);
+}
+#endif /* HAVE_INOTIFY_INIT */
+
+#if HAVE_INOTIFY_INIT1
+inline static int inotify_init1(int flags) {
+ return syscall(__NR_inotify_init1, flags);
+}
+#endif /* HAVE_INOTIFY_INIT1 */
+
+#if HAVE_INOTIFY_ADD_WATCH
+inline static int inotify_add_watch(int fd, const char* path, uint32_t mask) {
+ return syscall(__NR_inotify_add_watch, fd, path, mask);
+}
+#endif /* HAVE_INOTIFY_ADD_WATCH */
+
+#if HAVE_INOTIFY_RM_WATCH
+inline static int inotify_rm_watch(int fd, uint32_t wd) {
+ return syscall(__NR_inotify_rm_watch, fd, wd);
+}
+#endif /* HAVE_INOTIFY_RM_WATCH */
+
+
+/* Don't look aghast, this is exactly how glibc's basename() works. */
+static char* basename_r(const char* path) {
+ char* s = strrchr(path, '/');
+ return s ? (s + 1) : (char*)path;
+}
+
+
+static int compare_watchers(const uv_fs_event_t* a, const uv_fs_event_t* b) {
+ if (a->fd < b->fd) return -1;
+ if (a->fd > b->fd) return 1;
+ return 0;
+}
+
+
+RB_GENERATE_INTERNAL(uv__inotify_watchers, uv_fs_event_s, node, compare_watchers,
+ inline static __attribute__((unused)))
+
+
+void uv__inotify_loop_init(uv_loop_t* loop) {
+ RB_INIT(&loop->inotify_watchers);
+ loop->inotify_fd = -1;
+}
+
+
+void uv__inotify_loop_delete(uv_loop_t* loop) {
+ if (loop->inotify_fd == -1) return;
+ ev_io_stop(loop->ev, &loop->inotify_read_watcher);
+ close(loop->inotify_fd);
+ loop->inotify_fd = -1;
+}
+
+
+#if HAVE_INOTIFY_INIT || HAVE_INOTIFY_INIT1
+
+static void uv__inotify_read(EV_P_ ev_io* w, int revents);
+
+
+static int new_inotify_fd(void) {
+#if HAVE_INOTIFY_INIT1
+ return inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
+#else
+ int fd;
+
+ if ((fd = inotify_init()) == -1)
+ return -1;
+
+ if (uv__cloexec(fd, 1) || uv__nonblock(fd, 1)) {
+ SAVE_ERRNO(uv__close(fd));
+ return -1;
+ }
+
+ return fd;
+#endif
+}
+
+
+static int init_inotify(uv_loop_t* loop) {
+ if (loop->inotify_fd != -1)
+ return 0;
+
+ loop->inotify_fd = new_inotify_fd();
+ if (loop->inotify_fd == -1) {
+ uv__set_sys_error(loop, errno);
+ return -1;
+ }
+
+ ev_io_init(&loop->inotify_read_watcher,
+ uv__inotify_read,
+ loop->inotify_fd,
+ EV_READ);
+ ev_io_start(loop->ev, &loop->inotify_read_watcher);
+ ev_unref(loop->ev);
+
+ return 0;
+}
+
+
+static void add_watcher(uv_fs_event_t* handle) {
+ RB_INSERT(uv__inotify_watchers, &handle->loop->inotify_watchers, handle);
+}
+
+
+static uv_fs_event_t* find_watcher(uv_loop_t* loop, int wd) {
+ uv_fs_event_t handle;
+ handle.fd = wd;
+ return RB_FIND(uv__inotify_watchers, &loop->inotify_watchers, &handle);
+}
+
+
+static void remove_watcher(uv_fs_event_t* handle) {
+ RB_REMOVE(uv__inotify_watchers, &handle->loop->inotify_watchers, handle);
+}
+
+
+static void uv__inotify_read(EV_P_ ev_io* w, int revents) {
+ const struct inotify_event* e;
+ uv_fs_event_t* handle;
+ uv_loop_t* uv_loop;
+ const char* filename;
+ ssize_t size;
+ int events;
+ const char *p;
+ /* needs to be large enough for sizeof(inotify_event) + strlen(filename) */
+ char buf[4096];
+
+ uv_loop = container_of(w, uv_loop_t, inotify_read_watcher);
+
+ while (1) {
+ do {
+ size = read(uv_loop->inotify_fd, buf, sizeof buf);
+ }
+ while (size == -1 && errno == EINTR);
+
+ if (size == -1) {
+ assert(errno == EAGAIN || errno == EWOULDBLOCK);
+ break;
+ }
+
+ assert(size > 0); /* pre-2.6.21 thing, size=0 == read buffer too small */
+
+ /* Now we have one or more inotify_event structs. */
+ for (p = buf; p < buf + size; p += sizeof(*e) + e->len) {
+ e = (const struct inotify_event*)p;
+
+ events = 0;
+ if (e->mask & (IN_ATTRIB|IN_MODIFY))
+ events |= UV_CHANGE;
+ if (e->mask & ~(IN_ATTRIB|IN_MODIFY))
+ events |= UV_RENAME;
+
+ handle = find_watcher(uv_loop, e->wd);
+ if (handle == NULL)
+ continue; /* Handle has already been closed. */
+
+ /* inotify does not return the filename when monitoring a single file
+ * for modifications. Repurpose the filename for API compatibility.
+ * I'm not convinced this is a good thing, maybe it should go.
+ */
+ filename = e->len ? (const char*) (e + 1) : basename_r(handle->filename);
+
+ handle->cb(handle, filename, events, 0);
+ }
+ }
+}
+
+
+int uv_fs_event_init(uv_loop_t* loop,
+ uv_fs_event_t* handle,
+ const char* filename,
+ uv_fs_event_cb cb,
+ int flags) {
+ int events;
+ int wd;
+
+ loop->counters.fs_event_init++;
+
+ /* We don't support any flags yet. */
+ assert(!flags);
+
+ if (init_inotify(loop)) return -1;
+
+ events = IN_ATTRIB
+ | IN_CREATE
+ | IN_MODIFY
+ | IN_DELETE
+ | IN_DELETE_SELF
+ | IN_MOVED_FROM
+ | IN_MOVED_TO;
+
+ wd = inotify_add_watch(loop->inotify_fd, filename, events);
+ if (wd == -1) return uv__set_sys_error(loop, errno);
+
+ uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT);
+ handle->filename = strdup(filename);
+ handle->cb = cb;
+ handle->fd = wd;
+ add_watcher(handle);
+
+ return 0;
+}
+
+
+void uv__fs_event_destroy(uv_fs_event_t* handle) {
+ inotify_rm_watch(handle->loop->inotify_fd, handle->fd);
+ remove_watcher(handle);
+ handle->fd = -1;
+
+ free(handle->filename);
+ handle->filename = NULL;
+}
+
+#else /* !HAVE_INOTIFY_INIT || HAVE_INOTIFY_INIT1 */
+
+int uv_fs_event_init(uv_loop_t* loop,
+ uv_fs_event_t* handle,
+ const char* filename,
+ uv_fs_event_cb cb,
+ int flags) {
+ loop->counters.fs_event_init++;
+ uv__set_sys_error(loop, ENOSYS);
+ return -1;
+}
+
+
+void uv__fs_event_destroy(uv_fs_event_t* handle) {
+ UNREACHABLE();
+}
+
+#endif /* HAVE_INOTIFY_INIT || HAVE_INOTIFY_INIT1 */
}
int uv_exepath(char* buffer, size_t* size) {
- uint32_t usize;
- int result;
- char* path;
- char* fullpath;
int mib[4];
size_t cb;
pid_t mypid;
* IN THE SOFTWARE.
*/
+#include "uv.h"
+#include "internal.h"
+
#include <sys/types.h>
#include <sys/param.h>
#include <sys/resource.h>
+#include <sys/sched.h>
#include <sys/time.h>
#include <sys/sysctl.h>
#include <errno.h>
+#include <fcntl.h>
+#include <kvm.h>
+#include <paths.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
uv_err_t uv_resident_set_memory(size_t* rss) {
kvm_t *kd = NULL;
- struct kinfo_proc2 *kinfo = NULL;
+ struct kinfo_proc *kinfo = NULL;
pid_t pid;
- int nprocs, max_size = sizeof(struct kinfo_proc2);
+ int nprocs, max_size = sizeof(struct kinfo_proc);
size_t page_size = getpagesize();
pid = getpid();
kd = kvm_open(NULL, _PATH_MEM, NULL, O_RDONLY, "kvm_open");
if (kd == NULL) goto error;
- kinfo = kvm_getproc2(kd, KERN_PROC_PID, pid, max_size, &nprocs);
+ kinfo = kvm_getprocs(kd, KERN_PROC_PID, pid, max_size, &nprocs);
if (kinfo == NULL) goto error;
*rss = kinfo->p_vm_rssize * page_size;
uint64_t info[CPUSTATES];
char model[512];
int numcpus = 1;
- static int which[] = {CTL_HW, HW_MODEL, NULL};
+ static int which[] = {CTL_HW,HW_MODEL,0};
size_t size;
uv_cpu_info_t* cpu_info;
size = sizeof(model);
if (sysctl(which, 2, &model, &size, NULL, 0) < 0) {
- return -1;
+ return uv__new_sys_error(errno);
}
which[1] = HW_NCPU;
size = sizeof(numcpus);
if (sysctl(which, 2, &numcpus, &size, NULL, 0) < 0) {
- return -1;
+ return uv__new_sys_error(errno);
}
*cpu_infos = (uv_cpu_info_t*)malloc(numcpus * sizeof(uv_cpu_info_t));
cpu_info = &(*cpu_infos)[i];
- cpu_info->cpu_times.user = (uint64_t)(info[CP_USER]) * multiplier);
- cpu_info->cpu_times.nice = ((uint64_t)(info[CP_NICE]) * multiplier);
- cpu_info->cpu_times.sys = (uint64_t)(info[CP_SYS]) * multiplier));
- cpu_info->cpu_times.idle = (uint64_t)(info[CP_IDLE]) * multiplier));
- cpu_info->cpu_times.irq = (uint64_t)(info[CP_INTR]) * multiplier));
+ cpu_info->cpu_times.user = (uint64_t)(info[CP_USER]) * multiplier;
+ cpu_info->cpu_times.nice = (uint64_t)(info[CP_NICE]) * multiplier;
+ cpu_info->cpu_times.sys = (uint64_t)(info[CP_SYS]) * multiplier;
+ cpu_info->cpu_times.idle = (uint64_t)(info[CP_IDLE]) * multiplier;
+ cpu_info->cpu_times.irq = (uint64_t)(info[CP_INTR]) * multiplier;
cpu_info->model = strdup(model);
cpu_info->speed = cpuspeed;
int i;
for (i = 0; i < count; i++) {
- free(cpu_infos[i].brand);
+ free(cpu_infos[i].model);
}
free(cpu_infos);
#include <stdio.h>
#ifdef __APPLE__
+# include <TargetConditionals.h>
+#endif
+
+#if defined(__APPLE__) && !defined(TARGET_OS_IPHONE)
# include <crt_externs.h>
# define environ (*_NSGetEnviron())
#else
#undef UV_STRERROR_GEN
-void uv__set_error(uv_loop_t* loop, uv_err_code code, int sys_error) {
+int uv__set_error(uv_loop_t* loop, uv_err_code code, int sys_error) {
loop->last_err.code = code;
loop->last_err.sys_errno_ = sys_error;
+ return -1;
}
-void uv__set_sys_error(uv_loop_t* loop, int sys_error) {
+int uv__set_sys_error(uv_loop_t* loop, int sys_error) {
loop->last_err.code = uv_translate_sys_error(sys_error);
loop->last_err.sys_errno_ = sys_error;
+ return -1;
}
-void uv__set_artificial_error(uv_loop_t* loop, uv_err_code code) {
+int uv__set_artificial_error(uv_loop_t* loop, uv_err_code code) {
loop->last_err = uv__new_artificial_error(code);
+ return -1;
}
extern const uv_err_t uv_ok_;
uv_err_code uv_translate_sys_error(int sys_errno);
-void uv__set_error(uv_loop_t* loop, uv_err_code code, int sys_error);
-void uv__set_sys_error(uv_loop_t* loop, int sys_error);
-void uv__set_artificial_error(uv_loop_t* loop, uv_err_code code);
+int uv__set_error(uv_loop_t* loop, uv_err_code code, int sys_error);
+int uv__set_sys_error(uv_loop_t* loop, int sys_error);
+int uv__set_artificial_error(uv_loop_t* loop, uv_err_code code);
uv_err_t uv__new_sys_error(int sys_error);
uv_err_t uv__new_artificial_error(uv_err_code code);
OVERLAPPED overlapped, *overlapped_ptr;
LARGE_INTEGER offset_;
DWORD bytes;
+ DWORD error;
VERIFY_UV_FILE(file, req);
if (ReadFile(handle, buf, length, &bytes, overlapped_ptr)) {
SET_REQ_RESULT(req, bytes);
} else {
- SET_REQ_WIN32_ERROR(req, GetLastError());
+ error = GetLastError();
+ if (error == ERROR_HANDLE_EOF) {
+ SET_REQ_RESULT(req, bytes);
+ } else {
+ SET_REQ_WIN32_ERROR(req, error);
+ }
}
}
/* Whether ipv6 is supported */
extern int uv_allow_ipv6;
+/* Whether there are any non-IFS LSPs stacked on TCP */
+extern int uv_tcp_non_ifs_lsp_ipv4;
+extern int uv_tcp_non_ifs_lsp_ipv6;
+
/* Ip address used to bind to any port at any interface */
extern struct sockaddr_in uv_addr_ip4_any_;
extern struct sockaddr_in6 uv_addr_ip6_any_;
static int uv_tcp_set_socket(uv_loop_t* loop, uv_tcp_t* handle,
SOCKET socket, int imported) {
DWORD yes = 1;
+ int non_ifs_lsp;
assert(handle->socket == INVALID_SOCKET);
}
}
- if (pSetFileCompletionNotificationModes) {
+ non_ifs_lsp = (handle->flags & UV_HANDLE_IPV6) ? uv_tcp_non_ifs_lsp_ipv6 :
+ uv_tcp_non_ifs_lsp_ipv4;
+
+ if (pSetFileCompletionNotificationModes && !non_ifs_lsp) {
if (pSetFileCompletionNotificationModes((HANDLE) socket,
FILE_SKIP_SET_EVENT_ON_HANDLE |
FILE_SKIP_COMPLETION_PORT_ON_SUCCESS)) {
tcp->flags |= UV_HANDLE_BOUND;
tcp->flags |= UV_HANDLE_SHARED_TCP_SERVER;
+ if (socket_protocol_info->iAddressFamily == AF_INET6) {
+ tcp->flags |= UV_HANDLE_IPV6;
+ }
+
return uv_tcp_set_socket(tcp->loop, tcp, socket, 1);
}
/* Whether ipv6 is supported */
int uv_allow_ipv6;
+/* Whether there are any non-IFS LSPs stacked on TCP */
+int uv_tcp_non_ifs_lsp_ipv4;
+int uv_tcp_non_ifs_lsp_ipv6;
+
/* Ip address used to bind to any port at any interface */
struct sockaddr_in uv_addr_ip4_any_;
struct sockaddr_in6 uv_addr_ip6_any_;
WSADATA wsa_data;
int errorno;
- SOCKET dummy6;
+ SOCKET dummy;
+ WSAPROTOCOL_INFOW protocol_info;
+ int opt_len;
/* Initialize winsock */
errorno = WSAStartup(MAKEWORD(2, 2), &wsa_data);
uv_addr_ip4_any_ = uv_ip4_addr("0.0.0.0", 0);
uv_addr_ip6_any_ = uv_ip6_addr("::", 0);
- /* Detect IPV6 support */
- dummy6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_IP);
- if (dummy6 != INVALID_SOCKET) {
+ /* Detect non-IFS LSPs */
+ dummy = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
+ if (dummy == INVALID_SOCKET) {
+ uv_fatal_error(WSAGetLastError(), "socket");
+ }
+
+ opt_len = (int) sizeof protocol_info;
+ if (!getsockopt(dummy,
+ SOL_SOCKET,
+ SO_PROTOCOL_INFOW,
+ (char*) &protocol_info,
+ &opt_len) == SOCKET_ERROR) {
+ uv_fatal_error(WSAGetLastError(), "socket");
+ }
+
+ if (!(protocol_info.dwServiceFlags1 & XP1_IFS_HANDLES)) {
+ uv_tcp_non_ifs_lsp_ipv4 = 1;
+ }
+
+ if (closesocket(dummy) == SOCKET_ERROR) {
+ uv_fatal_error(WSAGetLastError(), "closesocket");
+ }
+
+ /* Detect IPV6 support and non-IFS LSPs */
+ dummy = socket(AF_INET6, SOCK_STREAM, IPPROTO_IP);
+ if (dummy != INVALID_SOCKET) {
uv_allow_ipv6 = TRUE;
- if (closesocket(dummy6) == SOCKET_ERROR) {
+
+ opt_len = (int) sizeof protocol_info;
+ if (!getsockopt(dummy,
+ SOL_SOCKET,
+ SO_PROTOCOL_INFOW,
+ (char*) &protocol_info,
+ &opt_len) == SOCKET_ERROR) {
+ uv_fatal_error(WSAGetLastError(), "socket");
+ }
+
+ if (!(protocol_info.dwServiceFlags1 & XP1_IFS_HANDLES)) {
+ uv_tcp_non_ifs_lsp_ipv6 = 1;
+ }
+
+ if (closesocket(dummy) == SOCKET_ERROR) {
uv_fatal_error(WSAGetLastError(), "closesocket");
}
}
uv_pipe_open(&channel, 0);
- ASSERT(uv_is_readable(&channel));
- ASSERT(uv_is_writable(&channel));
+ ASSERT(uv_is_readable((uv_stream_t*)&channel));
+ ASSERT(uv_is_writable((uv_stream_t*)&channel));
r = uv_tcp_init(uv_default_loop(), &tcp_server);
ASSERT(r == 0);
uv_fs_req_cleanup(req);
if (close_cb_count == 3) {
r = uv_fs_unlink(loop, &unlink_req, "test_file2", unlink_cb);
+ ASSERT(r == 0);
}
}
ftruncate_cb_count++;
uv_fs_req_cleanup(req);
r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);
+ ASSERT(r == 0);
}
ASSERT(strcmp(buf, "test-bu") == 0);
r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);
}
+ ASSERT(r == 0);
}
memset(buf, 0, sizeof(buf));
r = uv_fs_read(loop, &read_req, open_req1.result, buf, sizeof(buf), -1,
read_cb);
+ ASSERT(r == 0);
}
fsync_cb_count++;
uv_fs_req_cleanup(req);
r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);
+ ASSERT(r == 0);
}
fdatasync_cb_count++;
uv_fs_req_cleanup(req);
r = uv_fs_fsync(loop, &fsync_req, open_req1.result, fsync_cb);
+ ASSERT(r == 0);
}
write_cb_count++;
uv_fs_req_cleanup(req);
r = uv_fs_fdatasync(loop, &fdatasync_req, open_req1.result, fdatasync_cb);
+ ASSERT(r == 0);
}
uv_fs_req_cleanup(req);
r = uv_fs_write(loop, &write_req, req->result, test_buf, sizeof(test_buf),
-1, write_cb);
+ ASSERT(r == 0);
}
}],
[ 'OS=="linux"', {
'include_dirs': [ 'src/ares/config_linux' ],
- 'sources': [ 'src/unix/linux.c' ],
+ 'sources': [
+ 'src/unix/linux/core.c',
+ 'src/unix/linux/inotify.c',
+ ],
'defines': [
'EV_CONFIG_H="config_linux.h"',
'EIO_CONFIG_H="config_linux.h"',
projects / platform / upstream / nodejs.git / commitdiff