X-Git-Url: http://git.openwrt.org/?a=blobdiff_plain;f=uloop.c;h=da6f690cfad63f100f38510d087e81350cc1ea2b;hb=c1be505732e6d254464973bdeacb955214c76c46;hp=bd09260c11ccba68d414e441e7af9971f46add10;hpb=33b9f3aa0b59feb3c492684cdb4a5340ef3f18d9;p=project%2Flibubox.git diff --git a/uloop.c b/uloop.c index bd09260..da6f690 100644 --- a/uloop.c +++ b/uloop.c @@ -1,24 +1,20 @@ /* - * Copyright (C) 2010 Felix Fietkau - * Copyright (C) 2010 John Crispin - * Copyright (C) 2010 Steven Barth + * uloop - event loop implementation * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. + * Copyright (C) 2010-2016 Felix Fietkau * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ - #include #include @@ -30,261 +26,220 @@ #include #include #include +#include #include "uloop.h" +#include "utils.h" #ifdef USE_KQUEUE #include #endif #ifdef USE_EPOLL #include +#include #endif #include +struct uloop_fd_event { + struct uloop_fd *fd; + unsigned int events; +}; + +struct uloop_fd_stack { + struct uloop_fd_stack *next; + struct uloop_fd *fd; + unsigned int events; +}; + +static struct uloop_fd_stack *fd_stack = NULL; -#ifndef ARRAY_SIZE -#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) -#endif #define ULOOP_MAX_EVENTS 10 static struct list_head timeouts = LIST_HEAD_INIT(timeouts); static struct list_head processes = LIST_HEAD_INIT(processes); +static struct list_head signals = LIST_HEAD_INIT(signals); static int poll_fd = -1; bool uloop_cancelled = false; bool uloop_handle_sigchld = true; +static int uloop_status = 0; static bool do_sigchld = false; -static int cur_fd, cur_nfds; -#ifdef USE_KQUEUE +static struct uloop_fd_event cur_fds[ULOOP_MAX_EVENTS]; +static int cur_fd, cur_nfds; +static int uloop_run_depth = 0; -int uloop_init(void) -{ - if (poll_fd >= 0) - return 0; +uloop_fd_handler uloop_fd_set_cb = NULL; - poll_fd = kqueue(); - if (poll_fd < 0) - return -1; +int uloop_fd_add(struct uloop_fd *sock, unsigned int flags); - return 0; -} +#ifdef USE_KQUEUE +#include "uloop-kqueue.c" +#endif +#ifdef USE_EPOLL +#include "uloop-epoll.c" +#endif -static uint16_t get_flags(unsigned int flags, unsigned int mask) +static void set_signo(uint64_t *signums, int signo) { - uint16_t kflags = 0; - - if (!(flags & mask)) - return EV_DELETE; - - kflags = EV_ADD; - if (flags & ULOOP_EDGE_TRIGGER) - kflags |= EV_CLEAR; - - return kflags; + if (signo >= 1 && signo <= 64) + *signums |= (1u << (signo - 1)); } -static struct kevent events[ULOOP_MAX_EVENTS]; - -static int register_poll(struct uloop_fd *fd, unsigned int flags) +static bool get_signo(uint64_t signums, int signo) { - struct timespec timeout = { 0, 0 }; - struct kevent ev[2]; - unsigned int changed; - int nev = 0; - unsigned int fl = 0; - - changed = fd->kqflags ^ flags; - if (changed & ULOOP_EDGE_TRIGGER) - changed |= flags; - - if (changed & ULOOP_READ) { - uint16_t kflags = get_flags(flags, ULOOP_READ); - EV_SET(&ev[nev++], fd->fd, EVFILT_READ, kflags, 0, 0, fd); - } - - if (changed & ULOOP_WRITE) { - uint16_t kflags = get_flags(flags, ULOOP_WRITE); - EV_SET(&ev[nev++], fd->fd, EVFILT_WRITE, kflags, 0, 0, fd); - } - - if (!flags) - fl |= EV_DELETE; - - if (nev && (kevent(poll_fd, ev, nev, NULL, fl, &timeout) == -1)) - return -1; - - fd->kqflags = flags; - return 0; + return (signo >= 1) && (signo <= 64) && (signums & (1u << (signo - 1))); } -int uloop_fd_delete(struct uloop_fd *sock) +static void signal_consume(struct uloop_fd *fd, unsigned int events) { - int i; + struct uloop_signal *usig, *usig_next; + uint64_t signums = 0; + uint8_t buf[32]; + ssize_t nsigs; - for (i = cur_fd + 1; i < cur_nfds; i++) { - if (events[i].udata != sock) - continue; + do { + nsigs = read(fd->fd, buf, sizeof(buf)); - events[i].udata = NULL; + for (ssize_t i = 0; i < nsigs; i++) + set_signo(&signums, buf[i]); } + while (nsigs > 0); - sock->registered = false; - return register_poll(sock, 0); + list_for_each_entry_safe(usig, usig_next, &signals, list) + if (get_signo(signums, usig->signo)) + usig->cb(usig); } -static void uloop_run_events(int timeout) -{ - struct timespec ts; - int nfds, n; +static int waker_pipe = -1; +static struct uloop_fd waker_fd = { + .fd = -1, + .cb = signal_consume, +}; - if (timeout > 0) { - ts.tv_sec = timeout / 1000; - ts.tv_nsec = (timeout % 1000) * 1000000; - } +static void waker_init_fd(int fd) +{ + fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC); + fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK); +} - nfds = kevent(poll_fd, NULL, 0, events, ARRAY_SIZE(events), timeout > 0 ? &ts : NULL); - for(n = 0; n < nfds; ++n) - { - struct uloop_fd *u = events[n].udata; - unsigned int ev = 0; +static int waker_init(void) +{ + int fds[2]; - if (!u) - continue; + if (waker_pipe >= 0) + return 0; - if (events[n].flags & EV_ERROR) { - u->error = true; - uloop_fd_delete(u); - } + if (pipe(fds) < 0) + return -1; - if(events[n].filter == EVFILT_READ) - ev |= ULOOP_READ; - else if (events[n].filter == EVFILT_WRITE) - ev |= ULOOP_WRITE; + waker_init_fd(fds[0]); + waker_init_fd(fds[1]); + waker_pipe = fds[1]; - if (events[n].flags & EV_EOF) - u->eof = true; - else if (!ev) - continue; + waker_fd.fd = fds[0]; + waker_fd.cb = signal_consume; + uloop_fd_add(&waker_fd, ULOOP_READ); - if (u->cb) { - cur_fd = n; - cur_nfds = nfds; - u->cb(u, ev); - } - } - cur_nfds = 0; + return 0; } -#endif - -#ifdef USE_EPOLL - -/** - * FIXME: uClibc < 0.9.30.3 does not define EPOLLRDHUP for Linux >= 2.6.17 - */ -#ifndef EPOLLRDHUP -#define EPOLLRDHUP 0x2000 -#endif +static void uloop_setup_signals(bool add); int uloop_init(void) { - if (poll_fd >= 0) - return 0; + if (uloop_init_pollfd() < 0) + return -1; - poll_fd = epoll_create(32); - if (poll_fd < 0) + if (waker_init() < 0) { + uloop_done(); return -1; + } + + uloop_setup_signals(true); - fcntl(poll_fd, F_SETFD, fcntl(poll_fd, F_GETFD) | FD_CLOEXEC); return 0; } -static int register_poll(struct uloop_fd *fd, unsigned int flags) +static bool uloop_fd_stack_event(struct uloop_fd *fd, int events) { - struct epoll_event ev; - int op = fd->registered ? EPOLL_CTL_MOD : EPOLL_CTL_ADD; - - memset(&ev, 0, sizeof(struct epoll_event)); + struct uloop_fd_stack *cur; - if (flags & ULOOP_READ) - ev.events |= EPOLLIN | EPOLLRDHUP; + /* + * Do not buffer events for level-triggered fds, they will keep firing. + * Caller needs to take care of recursion issues. + */ + if (!(fd->flags & ULOOP_EDGE_TRIGGER)) + return false; - if (flags & ULOOP_WRITE) - ev.events |= EPOLLOUT; + for (cur = fd_stack; cur; cur = cur->next) { + if (cur->fd != fd) + continue; - if (flags & ULOOP_EDGE_TRIGGER) - ev.events |= EPOLLET; + if (events < 0) + cur->fd = NULL; + else + cur->events |= events | ULOOP_EVENT_BUFFERED; - ev.data.fd = fd->fd; - ev.data.ptr = fd; + return true; + } - return epoll_ctl(poll_fd, op, fd->fd, &ev); + return false; } -static struct epoll_event events[ULOOP_MAX_EVENTS]; - -int uloop_fd_delete(struct uloop_fd *sock) +static void uloop_run_events(int64_t timeout) { - int i; - - for (i = cur_fd + 1; i < cur_nfds; i++) { - if (events[i].data.ptr != sock) - continue; - - events[i].data.ptr = NULL; + struct uloop_fd_event *cur; + struct uloop_fd *fd; + + if (!cur_nfds) { + cur_fd = 0; + cur_nfds = uloop_fetch_events(timeout); + if (cur_nfds < 0) + cur_nfds = 0; } - sock->registered = false; - return epoll_ctl(poll_fd, EPOLL_CTL_DEL, sock->fd, 0); -} -static void uloop_run_events(int timeout) -{ - int n, nfds; + while (cur_nfds > 0) { + struct uloop_fd_stack stack_cur; + unsigned int events; - nfds = epoll_wait(poll_fd, events, ARRAY_SIZE(events), timeout); - for(n = 0; n < nfds; ++n) - { - struct uloop_fd *u = events[n].data.ptr; - unsigned int ev = 0; + cur = &cur_fds[cur_fd++]; + cur_nfds--; - if (!u) + fd = cur->fd; + events = cur->events; + if (!fd) continue; - if(events[n].events & (EPOLLERR|EPOLLHUP)) { - u->error = true; - uloop_fd_delete(u); - } - - if(!(events[n].events & (EPOLLRDHUP|EPOLLIN|EPOLLOUT|EPOLLERR|EPOLLHUP))) + if (!fd->cb) continue; - if(events[n].events & EPOLLRDHUP) - u->eof = true; - - if(events[n].events & EPOLLIN) - ev |= ULOOP_READ; + if (uloop_fd_stack_event(fd, cur->events)) + continue; - if(events[n].events & EPOLLOUT) - ev |= ULOOP_WRITE; + stack_cur.next = fd_stack; + stack_cur.fd = fd; + fd_stack = &stack_cur; + do { + stack_cur.events = 0; + fd->cb(fd, events); + events = stack_cur.events & ULOOP_EVENT_MASK; + } while (stack_cur.fd && events); + fd_stack = stack_cur.next; - if(u->cb) { - cur_fd = n; - cur_nfds = nfds; - u->cb(u, ev); - } + return; } - cur_nfds = 0; } -#endif - int uloop_fd_add(struct uloop_fd *sock, unsigned int flags) { unsigned int fl; int ret; + if (!(flags & (ULOOP_READ | ULOOP_WRITE))) + return uloop_fd_delete(sock); + if (!sock->registered && !(flags & ULOOP_BLOCKING)) { fl = fcntl(sock->fd, F_GETFL, 0); fl |= O_NONBLOCK; @@ -295,19 +250,49 @@ int uloop_fd_add(struct uloop_fd *sock, unsigned int flags) if (ret < 0) goto out; + if (uloop_fd_set_cb) + uloop_fd_set_cb(sock, flags); + + sock->flags = flags; sock->registered = true; sock->eof = false; + sock->error = false; out: return ret; } -static int tv_diff(struct timeval *t1, struct timeval *t2) +int uloop_fd_delete(struct uloop_fd *fd) { - if (t1->tv_sec != t2->tv_sec) - return (t1->tv_sec - t2->tv_sec) * 1000; - else - return (t1->tv_usec - t2->tv_usec) / 1000; + int ret; + int i; + + for (i = 0; i < cur_nfds; i++) { + if (cur_fds[cur_fd + i].fd != fd) + continue; + + cur_fds[cur_fd + i].fd = NULL; + } + + if (!fd->registered) + return 0; + + if (uloop_fd_set_cb) + uloop_fd_set_cb(fd, 0); + + fd->registered = false; + uloop_fd_stack_event(fd, -1); + ret = __uloop_fd_delete(fd); + fd->flags = 0; + + return ret; +} + +static int64_t tv_diff(struct timeval *t1, struct timeval *t2) +{ + return + (t1->tv_sec - t2->tv_sec) * 1000 + + (t1->tv_usec - t2->tv_usec) / 1000; } int uloop_timeout_add(struct uloop_timeout *timeout) @@ -331,6 +316,15 @@ int uloop_timeout_add(struct uloop_timeout *timeout) return 0; } +static void uloop_gettime(struct timeval *tv) +{ + struct timespec ts; + + clock_gettime(CLOCK_MONOTONIC, &ts); + tv->tv_sec = ts.tv_sec; + tv->tv_usec = ts.tv_nsec / 1000; +} + int uloop_timeout_set(struct uloop_timeout *timeout, int msecs) { struct timeval *time = &timeout->time; @@ -338,14 +332,14 @@ int uloop_timeout_set(struct uloop_timeout *timeout, int msecs) if (timeout->pending) uloop_timeout_cancel(timeout); - gettimeofday(&timeout->time, NULL); + uloop_gettime(time); time->tv_sec += msecs / 1000; time->tv_usec += (msecs % 1000) * 1000; if (time->tv_usec > 1000000) { time->tv_sec++; - time->tv_usec %= 100000; + time->tv_usec -= 1000000; } return uloop_timeout_add(timeout); @@ -362,6 +356,38 @@ int uloop_timeout_cancel(struct uloop_timeout *timeout) return 0; } +int uloop_timeout_remaining(struct uloop_timeout *timeout) +{ + int64_t td; + struct timeval now; + + if (!timeout->pending) + return -1; + + uloop_gettime(&now); + + td = tv_diff(&timeout->time, &now); + + if (td > INT_MAX) + return INT_MAX; + else if (td < INT_MIN) + return INT_MIN; + else + return (int)td; +} + +int64_t uloop_timeout_remaining64(struct uloop_timeout *timeout) +{ + struct timeval now; + + if (!timeout->pending) + return -1; + + uloop_gettime(&now); + + return tv_diff(&timeout->time, &now); +} + int uloop_process_add(struct uloop_process *p) { struct uloop_process *tmp; @@ -404,6 +430,9 @@ static void uloop_handle_processes(void) while (1) { pid = waitpid(-1, &ret, WNOHANG); + if (pid < 0 && errno == EINTR) + continue; + if (pid <= 0) return; @@ -421,55 +450,182 @@ static void uloop_handle_processes(void) } +int uloop_interval_set(struct uloop_interval *timer, unsigned int msecs) +{ + return timer_register(timer, msecs); +} + +int uloop_interval_cancel(struct uloop_interval *timer) +{ + return timer_remove(timer); +} + +int64_t uloop_interval_remaining(struct uloop_interval *timer) +{ + return timer_next(timer); +} + +static void uloop_signal_wake(int signo) +{ + uint8_t sigbyte = signo; + + if (signo == SIGCHLD) + do_sigchld = true; + + do { + if (write(waker_pipe, &sigbyte, 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(signo); } -static void uloop_sigchld(int signo) +static void uloop_install_handler(int signum, void (*handler)(int), struct sigaction* old, bool add) { - do_sigchld = true; + struct sigaction s; + struct sigaction *act; + + act = NULL; + sigaction(signum, NULL, &s); + + if (add) { + if (s.sa_handler == SIG_DFL) { /* Do not override existing custom signal handlers */ + memcpy(old, &s, sizeof(struct sigaction)); + s.sa_handler = handler; + s.sa_flags = 0; + act = &s; + } + } + else if (s.sa_handler == handler) { /* Do not restore if someone modified our handler */ + act = old; + } + + if (act != NULL) + sigaction(signum, act, NULL); } -static void uloop_setup_signals(void) +static void uloop_ignore_signal(int signum, bool ignore) { struct sigaction s; + void *new_handler = NULL; + + sigaction(signum, NULL, &s); - memset(&s, 0, sizeof(struct sigaction)); - s.sa_handler = uloop_handle_sigint; - s.sa_flags = 0; - sigaction(SIGINT, &s, NULL); + if (ignore) { + if (s.sa_handler == SIG_DFL) /* Ignore only if there isn't any custom handler */ + new_handler = SIG_IGN; + } else { + if (s.sa_handler == SIG_IGN) /* Restore only if noone modified our SIG_IGN */ + new_handler = SIG_DFL; + } - if (uloop_handle_sigchld) { - s.sa_handler = uloop_sigchld; - sigaction(SIGCHLD, &s, NULL); + if (new_handler) { + s.sa_handler = new_handler; + s.sa_flags = 0; + sigaction(signum, &s, NULL); } } -static int uloop_get_next_timeout(struct timeval *tv) +static void uloop_setup_signals(bool add) +{ + static struct sigaction old_sigint, old_sigchld, old_sigterm; + + uloop_install_handler(SIGINT, uloop_handle_sigint, &old_sigint, add); + uloop_install_handler(SIGTERM, uloop_handle_sigint, &old_sigterm, add); + + if (uloop_handle_sigchld) + uloop_install_handler(SIGCHLD, uloop_signal_wake, &old_sigchld, add); + + uloop_ignore_signal(SIGPIPE, add); +} + +int uloop_signal_add(struct uloop_signal *s) +{ + struct list_head *h = &signals; + struct uloop_signal *tmp; + struct sigaction sa; + + if (s->pending) + return -1; + + list_for_each_entry(tmp, &signals, list) { + if (tmp->signo > s->signo) { + h = &tmp->list; + break; + } + } + + list_add_tail(&s->list, h); + s->pending = true; + + sigaction(s->signo, NULL, &s->orig); + + if (s->orig.sa_handler != uloop_signal_wake) { + sa.sa_handler = uloop_signal_wake; + sa.sa_flags = 0; + sigemptyset(&sa.sa_mask); + sigaction(s->signo, &sa, NULL); + } + + return 0; +} + +int uloop_signal_delete(struct uloop_signal *s) +{ + if (!s->pending) + return -1; + + list_del(&s->list); + s->pending = false; + + if (s->orig.sa_handler != uloop_signal_wake) + sigaction(s->signo, &s->orig, NULL); + + return 0; +} + +int uloop_get_next_timeout(void) { struct uloop_timeout *timeout; - int diff; + struct timeval tv; + int64_t diff; if (list_empty(&timeouts)) return -1; + uloop_gettime(&tv); + timeout = list_first_entry(&timeouts, struct uloop_timeout, list); - diff = tv_diff(&timeout->time, tv); + diff = tv_diff(&timeout->time, &tv); if (diff < 0) return 0; + if (diff > INT_MAX) + return INT_MAX; return diff; } -static void uloop_process_timeouts(struct timeval *tv) +static void uloop_process_timeouts(void) { struct uloop_timeout *t; + struct timeval tv; + + if (list_empty(&timeouts)) + return; + uloop_gettime(&tv); while (!list_empty(&timeouts)) { t = list_first_entry(&timeouts, struct uloop_timeout, list); - if (tv_diff(&t->time, tv) > 0) + if (tv_diff(&t->time, &tv) > 0) break; uloop_timeout_cancel(t); @@ -494,31 +650,54 @@ static void uloop_clear_processes(void) uloop_process_delete(p); } -void uloop_run(void) +bool uloop_cancelling(void) { - struct timeval tv; + return uloop_run_depth > 0 && uloop_cancelled; +} - uloop_setup_signals(); - while(!uloop_cancelled) - { - gettimeofday(&tv, NULL); - uloop_process_timeouts(&tv); - if (uloop_cancelled) - break; +int uloop_run_timeout(int timeout) +{ + int next_time = 0; + + uloop_run_depth++; + + uloop_status = 0; + uloop_cancelled = false; + do { + uloop_process_timeouts(); if (do_sigchld) uloop_handle_processes(); - uloop_run_events(uloop_get_next_timeout(&tv)); - } + + if (uloop_cancelled) + break; + + next_time = uloop_get_next_timeout(); + if (timeout >= 0 && (next_time < 0 || timeout < next_time)) + next_time = timeout; + uloop_run_events(next_time); + } while (!uloop_cancelled && timeout < 0); + + --uloop_run_depth; + + return uloop_status; } void uloop_done(void) { - if (poll_fd < 0) - return; + uloop_setup_signals(false); - close(poll_fd); - poll_fd = -1; + if (poll_fd >= 0) { + 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();