X-Git-Url: http://git.archive.openwrt.org/?p=project%2Flibubox.git;a=blobdiff_plain;f=uloop.c;h=0c57753444e16f361afd8f2d51a180436323aec9;hp=f2eb50a64a32a835e83210a35110311ad46eb89f;hb=4bc3decf8743c0add93d434a639bb1b449b6da11;hpb=4b0aa9ccc22eff62e177b9777152e7937273b418 diff --git a/uloop.c b/uloop.c index f2eb50a..0c57753 100644 --- a/uloop.c +++ b/uloop.c @@ -58,110 +58,77 @@ static struct list_head processes = LIST_HEAD_INIT(processes); static int poll_fd = -1; bool uloop_cancelled = false; +static int uloop_status = 0; static bool do_sigchld = false; static struct uloop_fd_event cur_fds[ULOOP_MAX_EVENTS]; static int cur_fd, cur_nfds; +static int uloop_run_depth = 0; + +int uloop_fd_add(struct uloop_fd *sock, unsigned int flags); #ifdef USE_KQUEUE #include "uloop-kqueue.c" #endif #ifdef USE_EPOLL - -/** - * FIXME: uClibc < 0.9.30.3 does not define EPOLLRDHUP for Linux >= 2.6.17 - */ -#ifndef EPOLLRDHUP -#define EPOLLRDHUP 0x2000 +#include "uloop-epoll.c" #endif -int uloop_init(void) +static void waker_consume(struct uloop_fd *fd, unsigned int events) { - if (poll_fd >= 0) - return 0; - - poll_fd = epoll_create(32); - if (poll_fd < 0) - return -1; + char buf[4]; - fcntl(poll_fd, F_SETFD, fcntl(poll_fd, F_GETFD) | FD_CLOEXEC); - return 0; + while (read(fd->fd, buf, 4) > 0) + ; } -static int register_poll(struct uloop_fd *fd, unsigned int flags) -{ - struct epoll_event ev; - int op = fd->registered ? EPOLL_CTL_MOD : EPOLL_CTL_ADD; - - memset(&ev, 0, sizeof(struct epoll_event)); - - if (flags & ULOOP_READ) - ev.events |= EPOLLIN | EPOLLRDHUP; - - if (flags & ULOOP_WRITE) - ev.events |= EPOLLOUT; - - if (flags & ULOOP_EDGE_TRIGGER) - ev.events |= EPOLLET; - - ev.data.fd = fd->fd; - ev.data.ptr = fd; - fd->flags = flags; - - return epoll_ctl(poll_fd, op, fd->fd, &ev); -} - -static struct epoll_event events[ULOOP_MAX_EVENTS]; +static int waker_pipe = -1; +static struct uloop_fd waker_fd = { + .fd = -1, + .cb = waker_consume, +}; -static int __uloop_fd_delete(struct uloop_fd *sock) +static void waker_init_fd(int fd) { - sock->flags = 0; - return epoll_ctl(poll_fd, EPOLL_CTL_DEL, sock->fd, 0); + fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC); + fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK); } -static int uloop_fetch_events(int timeout) +static int waker_init(void) { - int n, nfds; - - nfds = epoll_wait(poll_fd, events, ARRAY_SIZE(events), timeout); - for (n = 0; n < nfds; ++n) { - struct uloop_fd_event *cur = &cur_fds[n]; - struct uloop_fd *u = events[n].data.ptr; - unsigned int ev = 0; + int fds[2]; - cur->fd = u; - if (!u) - continue; + if (waker_pipe >= 0) + return 0; - if (events[n].events & (EPOLLERR|EPOLLHUP)) { - u->error = true; - if (!(u->flags & ULOOP_ERROR_CB)) - uloop_fd_delete(u); - } + if (pipe(fds) < 0) + return -1; - if(!(events[n].events & (EPOLLRDHUP|EPOLLIN|EPOLLOUT|EPOLLERR|EPOLLHUP))) { - cur->fd = NULL; - continue; - } + waker_init_fd(fds[0]); + waker_init_fd(fds[1]); + waker_pipe = fds[1]; - if(events[n].events & EPOLLRDHUP) - u->eof = true; + waker_fd.fd = fds[0]; + waker_fd.cb = waker_consume; + uloop_fd_add(&waker_fd, ULOOP_READ); - if(events[n].events & EPOLLIN) - ev |= ULOOP_READ; + return 0; +} - if(events[n].events & EPOLLOUT) - ev |= ULOOP_WRITE; +int uloop_init(void) +{ + if (uloop_init_pollfd() < 0) + return -1; - cur->events = ev; + if (waker_init() < 0) { + uloop_done(); + return -1; } - return nfds; + return 0; } -#endif - static bool uloop_fd_stack_event(struct uloop_fd *fd, int events) { struct uloop_fd_stack *cur; @@ -399,6 +366,9 @@ static void uloop_handle_processes(void) while (1) { pid = waitpid(-1, &ret, WNOHANG); + if (pid < 0 && errno == EINTR) + continue; + if (pid <= 0) return; @@ -416,14 +386,28 @@ static void uloop_handle_processes(void) } +static void uloop_signal_wake(void) +{ + do { + if (write(waker_pipe, "w", 1) < 0) { + if (errno == EINTR) + continue; + } + break; + } while (1); +} + static void uloop_handle_sigint(int signo) { + uloop_status = signo; uloop_cancelled = true; + uloop_signal_wake(); } static void uloop_sigchld(int signo) { do_sigchld = true; + uloop_signal_wake(); } static void uloop_install_handler(int signum, void (*handler)(int), struct sigaction* old, bool add) @@ -531,20 +515,26 @@ static void uloop_clear_processes(void) uloop_process_delete(p); } -void uloop_run(void) +bool uloop_cancelling(void) +{ + return uloop_run_depth > 0 && uloop_cancelled; +} + +int uloop_run_timeout(int timeout) { - static int recursive_calls = 0; + int next_time = 0; struct timeval tv; /* * Handlers are only updated for the first call to uloop_run() (and restored * when this call is done). */ - if (!recursive_calls++) + if (!uloop_run_depth++) uloop_setup_signals(true); + uloop_status = 0; uloop_cancelled = false; - while(!uloop_cancelled) + while (!uloop_cancelled) { uloop_gettime(&tv); uloop_process_timeouts(&tv); @@ -556,20 +546,32 @@ void uloop_run(void) break; uloop_gettime(&tv); - uloop_run_events(uloop_get_next_timeout(&tv)); + + next_time = uloop_get_next_timeout(&tv); + if (timeout > 0 && timeout < next_time) + next_time = timeout; + uloop_run_events(next_time); } - if (!--recursive_calls) + if (!--uloop_run_depth) uloop_setup_signals(false); + + return uloop_status; } void uloop_done(void) { - if (poll_fd < 0) - return; + if (poll_fd >= 0) { + close(poll_fd); + poll_fd = -1; + } - close(poll_fd); - poll_fd = -1; + if (waker_pipe >= 0) { + uloop_fd_delete(&waker_fd); + close(waker_pipe); + close(waker_fd.fd); + waker_pipe = -1; + } uloop_clear_timeouts(); uloop_clear_processes();