X-Git-Url: http://git.archive.openwrt.org/?p=project%2Flibubox.git;a=blobdiff_plain;f=uloop.c;h=45f7c5d83858673885a1c602a6aa9ff189da8cdf;hp=deb08a3bfa1396a00bc76229e82a17652d0555c1;hb=004be15be4f3a8fb0cb781769338f91d0347dafc;hpb=510e4956e58727d68fbf7dea1646a344d6901c91 diff --git a/uloop.c b/uloop.c index deb08a3..45f7c5d 100644 --- a/uloop.c +++ b/uloop.c @@ -1,7 +1,7 @@ /* * uloop - event loop implementation * - * Copyright (C) 2010-2013 Felix Fietkau + * Copyright (C) 2010-2016 Felix Fietkau * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -56,241 +56,22 @@ static struct uloop_fd_stack *fd_stack = NULL; static struct list_head timeouts = LIST_HEAD_INIT(timeouts); static struct list_head processes = LIST_HEAD_INIT(processes); +static int signal_fd = -1; static int poll_fd = -1; bool uloop_cancelled = false; -bool uloop_handle_sigchld = true; static bool do_sigchld = false; static struct uloop_fd_event cur_fds[ULOOP_MAX_EVENTS]; static int cur_fd, cur_nfds; -#ifdef USE_KQUEUE - -int uloop_init(void) -{ - struct timespec timeout = { 0, 0 }; - struct kevent ev = {}; - - if (poll_fd >= 0) - return 0; - - poll_fd = kqueue(); - if (poll_fd < 0) - return -1; - - EV_SET(&ev, SIGCHLD, EVFILT_SIGNAL, EV_ADD, 0, 0, 0); - kevent(poll_fd, &ev, 1, NULL, 0, &timeout); - - return 0; -} - - -static uint16_t get_flags(unsigned int flags, unsigned int mask) -{ - uint16_t kflags = 0; - - if (!(flags & mask)) - return EV_DELETE; - - kflags = EV_ADD; - if (flags & ULOOP_EDGE_TRIGGER) - kflags |= EV_CLEAR; - - return kflags; -} - -static struct kevent events[ULOOP_MAX_EVENTS]; - -static int register_kevent(struct uloop_fd *fd, unsigned int flags) -{ - struct timespec timeout = { 0, 0 }; - struct kevent ev[2]; - int nev = 0; - unsigned int fl = 0; - unsigned int changed; - uint16_t kflags; - - if (flags & ULOOP_EDGE_DEFER) - flags &= ~ULOOP_EDGE_TRIGGER; - - changed = flags ^ fd->flags; - if (changed & ULOOP_EDGE_TRIGGER) - changed |= flags; - - if (changed & ULOOP_READ) { - kflags = get_flags(flags, ULOOP_READ); - EV_SET(&ev[nev++], fd->fd, EVFILT_READ, kflags, 0, 0, fd); - } - - if (changed & ULOOP_WRITE) { - kflags = get_flags(flags, ULOOP_WRITE); - EV_SET(&ev[nev++], fd->fd, EVFILT_WRITE, kflags, 0, 0, fd); - } - - if (!flags) - fl |= EV_DELETE; - - fd->flags = flags; - if (kevent(poll_fd, ev, nev, NULL, fl, &timeout) == -1) - return -1; - - return 0; -} - -static int register_poll(struct uloop_fd *fd, unsigned int flags) -{ - if (flags & ULOOP_EDGE_TRIGGER) - flags |= ULOOP_EDGE_DEFER; - else - flags &= ~ULOOP_EDGE_DEFER; - - return register_kevent(fd, flags); -} - -static int __uloop_fd_delete(struct uloop_fd *fd) -{ - return register_poll(fd, 0); -} - -static int uloop_fetch_events(int timeout) -{ - struct timespec ts; - int nfds, n; - - if (timeout >= 0) { - ts.tv_sec = timeout / 1000; - ts.tv_nsec = (timeout % 1000) * 1000000; - } - - nfds = kevent(poll_fd, NULL, 0, events, ARRAY_SIZE(events), timeout >= 0 ? &ts : NULL); - for (n = 0; n < nfds; n++) { - struct uloop_fd_event *cur = &cur_fds[n]; - struct uloop_fd *u = events[n].udata; - unsigned int ev = 0; - - cur->fd = u; - if (!u) - continue; - - if (events[n].flags & EV_ERROR) { - u->error = true; - uloop_fd_delete(u); - } - - if(events[n].filter == EVFILT_READ) - ev |= ULOOP_READ; - else if (events[n].filter == EVFILT_WRITE) - ev |= ULOOP_WRITE; - - if (events[n].flags & EV_EOF) - u->eof = true; - else if (!ev) - cur->fd = NULL; - - cur->events = ev; - if (u->flags & ULOOP_EDGE_DEFER) { - u->flags &= ~ULOOP_EDGE_DEFER; - u->flags |= ULOOP_EDGE_TRIGGER; - register_kevent(u, u->flags); - } - } - return nfds; -} +static void uloop_handle_signal(int signo); +#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 -#endif - -int uloop_init(void) -{ - if (poll_fd >= 0) - return 0; - - poll_fd = epoll_create(32); - if (poll_fd < 0) - return -1; - - 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) -{ - 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 __uloop_fd_delete(struct uloop_fd *sock) -{ - sock->flags = 0; - return epoll_ctl(poll_fd, EPOLL_CTL_DEL, sock->fd, 0); -} - -static int uloop_fetch_events(int timeout) -{ - 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; - - cur->fd = u; - if (!u) - continue; - - if (events[n].events & (EPOLLERR|EPOLLHUP)) { - u->error = true; - uloop_fd_delete(u); - } - - if(!(events[n].events & (EPOLLRDHUP|EPOLLIN|EPOLLOUT|EPOLLERR|EPOLLHUP))) { - cur->fd = NULL; - continue; - } - - if(events[n].events & EPOLLRDHUP) - u->eof = true; - - if(events[n].events & EPOLLIN) - ev |= ULOOP_READ; - - if(events[n].events & EPOLLOUT) - ev |= ULOOP_WRITE; - - cur->events = ev; - } - - return nfds; -} - +#include "uloop-epoll.c" #endif static bool uloop_fd_stack_event(struct uloop_fd *fd, int events) @@ -383,6 +164,7 @@ int uloop_fd_add(struct uloop_fd *sock, unsigned int flags) sock->registered = true; sock->eof = false; + sock->error = false; out: return ret; @@ -392,15 +174,16 @@ int uloop_fd_delete(struct uloop_fd *fd) { int i; - if (!fd->registered) - return 0; - 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; + fd->registered = false; uloop_fd_stack_event(fd, -1); return __uloop_fd_delete(fd); @@ -450,14 +233,14 @@ int uloop_timeout_set(struct uloop_timeout *timeout, int msecs) if (timeout->pending) uloop_timeout_cancel(timeout); - uloop_gettime(&timeout->time); + 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 %= 1000000; + time->tv_usec -= 1000000; } return uloop_timeout_add(timeout); @@ -528,6 +311,9 @@ static void uloop_handle_processes(void) while (1) { pid = waitpid(-1, &ret, WNOHANG); + if (pid < 0 && errno == EINTR) + continue; + if (pid <= 0) return; @@ -545,29 +331,78 @@ static void uloop_handle_processes(void) } -static void uloop_handle_sigint(int signo) +static void uloop_handle_signal(int signo) { - uloop_cancelled = true; + switch (signo) { + case SIGINT: + case SIGQUIT: + case SIGTERM: + uloop_cancelled = true; + break; + case SIGCHLD: + do_sigchld = true; + } } -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; - memset(&s, 0, sizeof(struct sigaction)); - s.sa_handler = uloop_handle_sigint; - s.sa_flags = 0; - sigaction(SIGINT, &s, NULL); + sigaction(signum, NULL, &s); - if (uloop_handle_sigchld) { - s.sa_handler = uloop_sigchld; - sigaction(SIGCHLD, &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 (new_handler) { + s.sa_handler = new_handler; + s.sa_flags = 0; + sigaction(signum, &s, NULL); + } +} + +static void uloop_setup_signals(bool add) +{ + static struct sigaction old_sigint, old_sigchld, old_sigterm; + + if (uloop_setup_signalfd(add)) + return; + + uloop_install_handler(SIGINT, uloop_handle_signal, &old_sigint, add); + uloop_install_handler(SIGTERM, uloop_handle_signal, &old_sigterm, add); + uloop_install_handler(SIGQUIT, uloop_handle_signal, &old_sigterm, add); + uloop_install_handler(SIGCHLD, uloop_handle_signal, &old_sigchld, add); + + uloop_ignore_signal(SIGPIPE, add); } static int uloop_get_next_timeout(struct timeval *tv) @@ -620,25 +455,43 @@ static void uloop_clear_processes(void) void uloop_run(void) { + static int recursive_calls = 0; struct timeval tv; - uloop_setup_signals(); + /* + * Handlers are only updated for the first call to uloop_run() (and restored + * when this call is done). + */ + if (!recursive_calls++) + uloop_setup_signals(true); + + uloop_cancelled = false; while(!uloop_cancelled) { uloop_gettime(&tv); uloop_process_timeouts(&tv); - if (uloop_cancelled) - break; if (do_sigchld) uloop_handle_processes(); + + if (uloop_cancelled) + break; + uloop_gettime(&tv); uloop_run_events(uloop_get_next_timeout(&tv)); } + + if (!--recursive_calls) + uloop_setup_signals(false); } void uloop_done(void) { + if (signal_fd >= 0) { + close(signal_fd); + signal_fd = -1; + } + if (poll_fd < 0) return;