Skip to content
This repository has been archived by the owner. It is now read-only.
Permalink
Browse files

Revert "uv: upgrade to b7e150ee"

Upgrade wasn't done correctly.
This reverts commit b615077.
  • Loading branch information...
piscisaureus committed Jun 12, 2012
1 parent b615077 commit cbeeea62cf10bbf71636fe03282590050beb1d36
@@ -100,9 +100,7 @@ struct ngx_queue_s {


#define ngx_queue_foreach(q, h) \
for ((q) = ngx_queue_head(h); \
(q) != ngx_queue_sentinel(h); \
(q) = ngx_queue_next(q))
for ((q) = ngx_queue_head(h); (q) != (h); (q) = ngx_queue_next(q))


#endif /* NGX_QUEUE_H_INCLUDED_ */
@@ -38,7 +38,6 @@

#include <semaphore.h>
#include <pthread.h>
#include <signal.h>

#if __sun
# include <sys/port.h>
@@ -114,9 +113,6 @@ struct uv__io_s {
ngx_queue_t prepare_handles; \
ngx_queue_t check_handles; \
ngx_queue_t idle_handles; \
ngx_queue_t async_handles; \
uv__io_t async_watcher; \
int async_pipefd[2]; \
/* RB_HEAD(uv__timers, uv_timer_s) */ \
struct uv__timers { struct uv_timer_s* rbh_root; } timer_handles; \
uint64_t time; \
@@ -215,10 +211,9 @@ struct uv__io_s {


/* UV_ASYNC */
#define UV_ASYNC_PRIVATE_FIELDS \
volatile sig_atomic_t pending; \
uv_async_cb async_cb; \
ngx_queue_t queue;
#define UV_ASYNC_PRIVATE_FIELDS \
ev_async async_watcher; \
uv_async_cb async_cb;


/* UV_TIMER */
@@ -21,99 +21,40 @@
#include "uv.h"
#include "internal.h"

#include <errno.h>
#include <assert.h>
#include <stdlib.h>
#include <unistd.h>

static int uv__async_init(uv_loop_t* loop);
static void uv__async_io(uv_loop_t* loop, uv__io_t* handle, int events);
static void uv__async(EV_P_ ev_async* w, int revents) {
uv_async_t* async = container_of(w, uv_async_t, async_watcher);

if (async->async_cb) {
async->async_cb(async, 0);
}
}

int uv_async_init(uv_loop_t* loop, uv_async_t* handle, uv_async_cb async_cb) {
if (uv__async_init(loop))
return uv__set_sys_error(loop, errno);

uv__handle_init(loop, (uv_handle_t*)handle, UV_ASYNC);
int uv_async_init(uv_loop_t* loop, uv_async_t* async, uv_async_cb async_cb) {
uv__handle_init(loop, (uv_handle_t*)async, UV_ASYNC);
loop->counters.async_init++;

handle->async_cb = async_cb;
handle->pending = 0;
ev_async_init(&async->async_watcher, uv__async);
async->async_cb = async_cb;

ngx_queue_insert_tail(&loop->async_handles, &handle->queue);
uv__handle_start(handle);
/* Note: This does not have symmetry with the other libev wrappers. */
ev_async_start(loop->ev, &async->async_watcher);
uv__handle_unref(async);
uv__handle_start(async);

return 0;
}


int uv_async_send(uv_async_t* handle) {
int r;

handle->pending = 1; /* XXX needs a memory barrier? */

do
r = write(handle->loop->async_pipefd[1], "x", 1);
while (r == -1 && errno == EINTR);

if (r == -1 && errno != EAGAIN && errno != EWOULDBLOCK)
return uv__set_sys_error(handle->loop, errno);

int uv_async_send(uv_async_t* async) {
ev_async_send(async->loop->ev, &async->async_watcher);
return 0;
}


void uv__async_close(uv_async_t* handle) {
ngx_queue_remove(&handle->queue);
ev_async_stop(handle->loop->ev, &handle->async_watcher);
uv__handle_ref(handle);
uv__handle_stop(handle);
}


static int uv__async_init(uv_loop_t* loop) {
if (loop->async_pipefd[0] != -1)
return 0;

if (uv__make_pipe(loop->async_pipefd, UV__F_NONBLOCK))
return -1;

uv__io_init(&loop->async_watcher,
uv__async_io,
loop->async_pipefd[0],
UV__IO_READ);
uv__io_start(loop, &loop->async_watcher);

return 0;
}


static void uv__async_io(uv_loop_t* loop, uv__io_t* handle, int events) {
char buf[1024];
ngx_queue_t* q;
uv_async_t* h;
ssize_t r;

while (1) {
r = read(loop->async_pipefd[0], buf, sizeof(buf));

if (r == sizeof(buf))
continue;

if (r != -1)
break;

if (errno == EAGAIN || errno == EWOULDBLOCK)
break;

if (errno == EINTR)
continue;

abort();
}

ngx_queue_foreach(q, &loop->async_handles) {
h = ngx_queue_data(q, uv_async_t, queue);
if (!h->pending) continue;
h->pending = 0;
h->async_cb(h, 0);
}
}
@@ -233,9 +233,6 @@ static unsigned int uv__poll_timeout(uv_loop_t* loop) {
if (!ngx_queue_empty(&loop->idle_handles))
return 0;

if (loop->closing_handles)
return 0;

return uv__next_timeout(loop);
}

@@ -29,7 +29,7 @@
#include <time.h>

#undef NANOSEC
#define NANOSEC ((uint64_t) 1e9)
#define NANOSEC 1000000000


uint64_t uv_hrtime() {
@@ -31,7 +31,6 @@ static int uv__dlerror(uv_lib_t* lib);


int uv_dlopen(const char* filename, uv_lib_t* lib) {
dlerror(); /* Reset error status. */
lib->errmsg = NULL;
lib->handle = dlopen(filename, RTLD_LAZY);
return uv__dlerror(lib);
@@ -38,7 +38,7 @@
#include <fcntl.h>

#undef NANOSEC
#define NANOSEC ((uint64_t) 1e9)
#define NANOSEC 1000000000

#ifndef CPUSTATES
# define CPUSTATES 5U
@@ -168,12 +168,8 @@ void uv__timer_close(uv_timer_t* handle);
void uv__udp_close(uv_udp_t* handle);
void uv__udp_finish_close(uv_udp_t* handle);

#ifdef UV__O_NONBLOCK
# define UV__F_NONBLOCK UV__O_NONBLOCK
#else
# define UV__F_NONBLOCK 1
#endif

#define UV__F_IPC (1 << 0)
#define UV__F_NONBLOCK (1 << 1)
int uv__make_socketpair(int fds[2], int flags);
int uv__make_pipe(int fds[2], int flags);

@@ -46,7 +46,7 @@
#endif

#undef NANOSEC
#define NANOSEC ((uint64_t) 1e9)
#define NANOSEC 1000000000

/* This is rather annoying: CLOCK_BOOTTIME lives in <linux/time.h> but we can't
* include that file because it conflicts with <time.h>. We'll just have to
@@ -49,26 +49,6 @@
# endif
#endif /* __NR_accept4 */

#ifndef __NR_eventfd
# if __x86_64__
# define __NR_eventfd 284
# elif __i386__
# define __NR_eventfd 323
# elif __arm__
# define __NR_eventfd (UV_SYSCALL_BASE + 351)
# endif
#endif /* __NR_eventfd */

#ifndef __NR_eventfd2
# if __x86_64__
# define __NR_eventfd2 290
# elif __i386__
# define __NR_eventfd2 328
# elif __arm__
# define __NR_eventfd2 (UV_SYSCALL_BASE + 356)
# endif
#endif /* __NR_eventfd2 */

#ifndef __NR_inotify_init
# if __x86_64__
# define __NR_inotify_init 253
@@ -167,24 +147,6 @@ int uv__accept4(int fd, struct sockaddr* addr, socklen_t* addrlen, int flags) {
}


int uv__eventfd(unsigned int count) {
#if __NR_eventfd
return syscall(__NR_eventfd, count);
#else
return errno = ENOSYS, -1;
#endif
}


int uv__eventfd2(unsigned int count, int flags) {
#if __NR_eventfd2
return syscall(__NR_eventfd2, count, flags);
#else
return errno = ENOSYS, -1;
#endif
}


int uv__inotify_init(void) {
#if __NR_inotify_init
return syscall(__NR_inotify_init);
@@ -32,16 +32,12 @@
#define UV__O_NONBLOCK 0x800
#define UV__O_CLOEXEC 0x80000

#define UV__EFD_CLOEXEC UV__O_CLOEXEC
#define UV__EFD_NONBLOCK UV__O_NONBLOCK
#define UV__SOCK_CLOEXEC UV__O_CLOEXEC
#define UV__SOCK_NONBLOCK UV__O_NONBLOCK

#define UV__IN_CLOEXEC UV__O_CLOEXEC
#define UV__IN_NONBLOCK UV__O_NONBLOCK

#define UV__SOCK_CLOEXEC UV__O_CLOEXEC
#define UV__SOCK_NONBLOCK UV__O_NONBLOCK

/* inotify flags */
#define UV__IN_ACCESS 0x001
#define UV__IN_MODIFY 0x002
#define UV__IN_ATTRIB 0x004
@@ -69,8 +65,6 @@ struct uv__mmsghdr {
};

int uv__accept4(int fd, struct sockaddr* addr, socklen_t* addrlen, int flags);
int uv__eventfd(unsigned int count);
int uv__eventfd2(unsigned int count, int flags);
int uv__inotify_init(void);
int uv__inotify_init1(int flags);
int uv__inotify_add_watch(int fd, const char* path, __u32 mask);
@@ -40,15 +40,12 @@ int uv__loop_init(uv_loop_t* loop, int default_loop) {
RB_INIT(&loop->timer_handles);
ngx_queue_init(&loop->active_reqs);
ngx_queue_init(&loop->idle_handles);
ngx_queue_init(&loop->async_handles);
ngx_queue_init(&loop->check_handles);
ngx_queue_init(&loop->prepare_handles);
ngx_queue_init(&loop->handle_queue);
loop->closing_handles = NULL;
loop->channel = NULL;
loop->time = uv_hrtime() / 1000000;
loop->async_pipefd[0] = -1;
loop->async_pipefd[1] = -1;
loop->ev = (default_loop ? ev_default_loop : ev_loop_new)(flags);
ev_set_userdata(loop->ev, loop);
eio_channel_init(&loop->uv_eio_channel, loop);
@@ -32,7 +32,7 @@
#include <time.h>

#undef NANOSEC
#define NANOSEC ((uint64_t) 1e9)
#define NANOSEC 1000000000


uint64_t uv_hrtime(void) {
@@ -37,7 +37,7 @@
#include <unistd.h>

#undef NANOSEC
#define NANOSEC ((uint64_t) 1e9)
#define NANOSEC 1000000000


static char *process_title;
@@ -68,15 +68,25 @@ static void uv__chld(EV_P_ ev_child* watcher, int revents) {


int uv__make_socketpair(int fds[2], int flags) {
#if __linux__
if (socketpair(AF_UNIX, SOCK_STREAM | UV__SOCK_CLOEXEC | flags, 0, fds) == 0)
#ifdef SOCK_NONBLOCK
int fl;

fl = SOCK_CLOEXEC;

if (flags & UV__F_NONBLOCK)
fl |= SOCK_NONBLOCK;

if (socketpair(AF_UNIX, SOCK_STREAM|fl, 0, fds) == 0)
return 0;

/* Retry on EINVAL, it means SOCK_CLOEXEC is not supported.
* Anything else is a genuine error.
*/
if (errno != EINVAL)
return -1;

/* errno == EINVAL so maybe the kernel headers lied about
* the availability of SOCK_NONBLOCK. This can happen if people
* build libuv against newer kernel headers than the kernel
* they actually run the software on.
*/
#endif

if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds))
@@ -96,7 +106,14 @@ int uv__make_socketpair(int fds[2], int flags) {

int uv__make_pipe(int fds[2], int flags) {
#if __linux__
if (uv__pipe2(fds, flags | UV__O_CLOEXEC) == 0)
int fl;

fl = UV__O_CLOEXEC;

if (flags & UV__F_NONBLOCK)
fl |= UV__O_NONBLOCK;

if (uv__pipe2(fds, fl) == 0)
return 0;

if (errno != ENOSYS)
@@ -708,7 +708,7 @@ int uv_shutdown(uv_shutdown_t* req, uv_stream_t* stream, uv_shutdown_cb cb) {
stream->flags & UV_STREAM_SHUT ||
stream->flags & UV_CLOSED ||
stream->flags & UV_CLOSING) {
uv__set_artificial_error(stream->loop, UV_ENOTCONN);
uv__set_sys_error(stream->loop, EINVAL);
return -1;
}

0 comments on commit cbeeea6

Please sign in to comment.
You can’t perform that action at this time.