X-Git-Url: http://git.archive.openwrt.org/?p=project%2Flibubox.git;a=blobdiff_plain;f=uloop.c;h=f226f505b417b479bc8d215bd77d4830055cbec6;hp=627ba1c58a3b321cdfeae025c12a71d4ccbb96f4;hb=cddd9326dc9686a450005c8d53a36b06e3e60e8e;hpb=e82d74f89809c6c01f71168b3b8fdcf490e93fa7 diff --git a/uloop.c b/uloop.c index 627ba1c..f226f50 100644 --- a/uloop.c +++ b/uloop.c @@ -21,7 +21,6 @@ #include #include -#include #include #include @@ -30,11 +29,136 @@ #include #include #include -#include #include #include "uloop.h" +#ifdef USE_KQUEUE +#include +#endif +#ifdef USE_EPOLL +#include +#endif +#include + + +#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 int poll_fd = -1; +bool uloop_cancelled = false; +bool uloop_handle_sigchld = true; +static bool do_sigchld = false; + +#ifdef USE_KQUEUE + +int uloop_init(void) +{ + if (poll_fd >= 0) + return 0; + + poll_fd = kqueue(); + if (poll_fd < 0) + return -1; + + 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 int register_poll(struct uloop_fd *fd, unsigned int flags) +{ + struct timespec timeout = { 0, 0 }; + struct kevent ev[2]; + unsigned int changed; + int nev = 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 (nev && (kevent(poll_fd, ev, nev, NULL, 0, &timeout) == -1)) + return -1; + + fd->kqflags = flags; + return 0; +} + +int uloop_fd_delete(struct uloop_fd *sock) +{ + sock->registered = false; + return register_poll(sock, 0); +} + +static void uloop_run_events(int timeout) +{ + struct kevent events[ULOOP_MAX_EVENTS]; + 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 *u = events[n].udata; + unsigned int ev = 0; + + 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) + continue; + + if(u->cb) + u->cb(u, ev); + } +} + +#endif + +#ifdef USE_EPOLL + /** * FIXME: uClibc < 0.9.30.3 does not define EPOLLRDHUP for Linux >= 2.6.17 */ @@ -42,26 +166,23 @@ #define EPOLLRDHUP 0x2000 #endif -#ifndef ARRAY_SIZE -#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) -#endif +int uloop_init(void) +{ + if (poll_fd >= 0) + return 0; -struct uloop_timeout *first_timeout; -static int epoll_fd; -static bool cancel; + poll_fd = epoll_create(32); + if (poll_fd < 0) + return -1; -int uloop_fd_add(struct uloop_fd *sock, unsigned int flags) + 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 = sock->registered ? EPOLL_CTL_MOD : EPOLL_CTL_ADD; - unsigned int fl; - int ret; - - if (!sock->registered) { - fl = fcntl(sock->fd, F_GETFL, 0); - fl |= O_NONBLOCK; - fcntl(sock->fd, F_SETFL, fl); - } + int op = fd->registered ? EPOLL_CTL_MOD : EPOLL_CTL_ADD; memset(&ev, 0, sizeof(struct epoll_event)); @@ -74,10 +195,65 @@ int uloop_fd_add(struct uloop_fd *sock, unsigned int flags) if (flags & ULOOP_EDGE_TRIGGER) ev.events |= EPOLLET; - ev.data.fd = sock->fd; - ev.data.ptr = sock; + ev.data.fd = fd->fd; + ev.data.ptr = fd; + + return epoll_ctl(poll_fd, op, fd->fd, &ev); +} + +int uloop_fd_delete(struct uloop_fd *sock) +{ + sock->registered = false; + return epoll_ctl(poll_fd, EPOLL_CTL_DEL, sock->fd, 0); +} + +static void uloop_run_events(int timeout) +{ + struct epoll_event events[ULOOP_MAX_EVENTS]; + int nfds, n; + + 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; + + if(events[n].events & EPOLLERR) { + u->error = true; + uloop_fd_delete(u); + } + + if(!(events[n].events & (EPOLLRDHUP|EPOLLIN|EPOLLOUT|EPOLLERR))) + 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; + + if(u->cb) + u->cb(u, ev); + } +} + +#endif + +int uloop_fd_add(struct uloop_fd *sock, unsigned int flags) +{ + unsigned int fl; + int ret; + + if (!sock->registered && !(flags & ULOOP_BLOCKING)) { + fl = fcntl(sock->fd, F_GETFL, 0); + fl |= O_NONBLOCK; + fcntl(sock->fd, F_SETFL, fl); + } - ret = epoll_ctl(epoll_fd, op, sock->fd, &ev); + ret = register_poll(sock, flags); if (ret < 0) goto out; @@ -88,12 +264,6 @@ out: return ret; } -int uloop_fd_delete(struct uloop_fd *sock) -{ - sock->registered = false; - return epoll_ctl(epoll_fd, EPOLL_CTL_DEL, sock->fd, 0); -} - static int tv_diff(struct timeval *t1, struct timeval *t2) { if (t1->tv_sec != t2->tv_sec) @@ -104,25 +274,20 @@ static int tv_diff(struct timeval *t1, struct timeval *t2) int uloop_timeout_add(struct uloop_timeout *timeout) { - struct uloop_timeout **head = &first_timeout; - struct uloop_timeout *prev = NULL; + struct uloop_timeout *tmp; + struct list_head *h = &timeouts; if (timeout->pending) return -1; - while (*head) { - if (tv_diff(&(*head)->time, &timeout->time) > 0) + list_for_each_entry(tmp, &timeouts, list) { + if (tv_diff(&tmp->time, &timeout->time) > 0) { + h = &tmp->list; break; - - prev = *head; - head = &(*head)->next; + } } - timeout->prev = prev; - timeout->next = *head; - if (timeout->next) - timeout->next->prev = timeout; - *head = timeout; + list_add_tail(&timeout->list, h); timeout->pending = true; return 0; @@ -153,41 +318,106 @@ int uloop_timeout_cancel(struct uloop_timeout *timeout) if (!timeout->pending) return -1; - if (timeout->prev) - timeout->prev->next = timeout->next; - else - first_timeout = timeout->next; + list_del(&timeout->list); + timeout->pending = false; + + return 0; +} - if (timeout->next) - timeout->next->prev = timeout->prev; +int uloop_process_add(struct uloop_process *p) +{ + struct uloop_process *tmp; + struct list_head *h = &processes; - timeout->pending = false; + if (p->pending) + return -1; + + list_for_each_entry(tmp, &processes, list) { + if (tmp->pid > p->pid) { + h = &tmp->list; + break; + } + } + + list_add_tail(&p->list, h); + p->pending = true; + + return 0; +} + +int uloop_process_delete(struct uloop_process *p) +{ + if (!p->pending) + return -1; + + list_del(&p->list); + p->pending = false; return 0; } +static void uloop_handle_processes(void) +{ + struct uloop_process *p, *tmp; + pid_t pid; + int ret; + + do_sigchld = false; + + while (1) { + pid = waitpid(-1, &ret, WNOHANG); + if (pid <= 0) + return; + + list_for_each_entry_safe(p, tmp, &processes, list) { + if (p->pid < pid) + continue; + + if (p->pid > pid) + break; + + uloop_process_delete(p); + p->cb(p, ret); + } + } + +} + static void uloop_handle_sigint(int signo) { - cancel = true; + uloop_cancelled = true; +} + +static void uloop_sigchld(int signo) +{ + do_sigchld = true; } static void uloop_setup_signals(void) { struct sigaction s; + memset(&s, 0, sizeof(struct sigaction)); s.sa_handler = uloop_handle_sigint; s.sa_flags = 0; sigaction(SIGINT, &s, NULL); + + if (uloop_handle_sigchld) { + s.sa_handler = uloop_sigchld; + sigaction(SIGCHLD, &s, NULL); + } } static int uloop_get_next_timeout(struct timeval *tv) { + struct uloop_timeout *timeout; int diff; - if (!first_timeout) + if (list_empty(&timeouts)) return -1; - diff = tv_diff(&first_timeout->time, tv); + timeout = list_first_entry(&timeouts, struct uloop_timeout, list); + diff = tv_diff(&timeout->time, tv); if (diff < 0) return 0; @@ -196,77 +426,41 @@ static int uloop_get_next_timeout(struct timeval *tv) static void uloop_process_timeouts(struct timeval *tv) { - struct uloop_timeout *timeout; + struct uloop_timeout *t, *tmp; - while (first_timeout) { - if (tv_diff(&first_timeout->time, tv) > 0) + list_for_each_entry_safe(t, tmp, &timeouts, list) { + if (tv_diff(&t->time, tv) > 0) break; - timeout = first_timeout; - uloop_timeout_cancel(timeout); - if (timeout->cb) - timeout->cb(timeout); + uloop_timeout_cancel(t); + if (t->cb) + t->cb(t); } } -void uloop_end(void) -{ - cancel = true; -} - -int uloop_init(void) -{ - epoll_fd = epoll_create(32); - if (epoll_fd < 0) - return -1; - - fcntl(epoll_fd, F_SETFD, fcntl(epoll_fd, F_GETFD) | FD_CLOEXEC); - return 0; -} - void uloop_run(void) { - struct epoll_event events[10]; struct timeval tv; - int timeout; - int nfds, n; uloop_setup_signals(); - while(!cancel) + while(!uloop_cancelled) { gettimeofday(&tv, NULL); uloop_process_timeouts(&tv); - timeout = uloop_get_next_timeout(&tv); - nfds = epoll_wait(epoll_fd, events, ARRAY_SIZE(events), timeout); - for(n = 0; n < nfds; ++n) - { - struct uloop_fd *u = events[n].data.ptr; - unsigned int ev = 0; - - if(events[n].events & EPOLLERR) { - u->error = true; - uloop_fd_delete(u); - } - - if(!(events[n].events & (EPOLLRDHUP|EPOLLIN|EPOLLOUT|EPOLLERR))) - 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; + if (uloop_cancelled) + break; - if(u->cb) - u->cb(u, ev); - } + if (do_sigchld) + uloop_handle_processes(); + uloop_run_events(uloop_get_next_timeout(&tv)); } } void uloop_done(void) { - close(epoll_fd); + if (poll_fd < 0) + return; + + close(poll_fd); + poll_fd = -1; }