324 lines
6.5 KiB
C
324 lines
6.5 KiB
C
/*
|
|
* uloop - event loop implementation
|
|
*
|
|
* Copyright (C) 2010-2016 Felix Fietkau <nbd@openwrt.org>
|
|
*
|
|
* 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 <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <fcntl.h>
|
|
#include <stdbool.h>
|
|
#include <signal.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/epoll.h>
|
|
|
|
#include "nloop.h"
|
|
|
|
#ifndef ARRAY_SIZE
|
|
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
|
|
#endif
|
|
#define ULOOP_MAX_EVENTS 10
|
|
|
|
/**
|
|
* FIXME: uClibc < 0.9.30.3 does not define EPOLLRDHUP for Linux >= 2.6.17
|
|
*/
|
|
#ifndef EPOLLRDHUP
|
|
#define EPOLLRDHUP 0x2000
|
|
#endif
|
|
|
|
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;
|
|
|
|
static int poll_fd = -1;
|
|
bool uloop_cancelled = false;
|
|
static int uloop_status = 0;
|
|
|
|
static struct uloop_fd_event cur_fds[ULOOP_MAX_EVENTS];
|
|
static int cur_fd, cur_nfds;
|
|
|
|
int uloop_fd_add(struct uloop_fd *sock, unsigned int flags);
|
|
|
|
static int uloop_init_pollfd(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.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;
|
|
if (!(u->flags & ULOOP_ERROR_CB))
|
|
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;
|
|
}
|
|
|
|
static bool uloop_fd_stack_event(struct uloop_fd *fd, int events)
|
|
{
|
|
struct uloop_fd_stack *cur;
|
|
|
|
/*
|
|
* 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;
|
|
|
|
for (cur = fd_stack; cur; cur = cur->next) {
|
|
if (cur->fd != fd)
|
|
continue;
|
|
|
|
if (events < 0)
|
|
cur->fd = NULL;
|
|
else
|
|
cur->events |= events | ULOOP_EVENT_BUFFERED;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static void uloop_run_events(int timeout)
|
|
{
|
|
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;
|
|
}
|
|
|
|
while (cur_nfds > 0) {
|
|
struct uloop_fd_stack stack_cur;
|
|
unsigned int events;
|
|
|
|
cur = &cur_fds[cur_fd++];
|
|
cur_nfds--;
|
|
|
|
fd = cur->fd;
|
|
events = cur->events;
|
|
if (!fd)
|
|
continue;
|
|
|
|
if (!fd->cb)
|
|
continue;
|
|
|
|
if (uloop_fd_stack_event(fd, cur->events))
|
|
continue;
|
|
|
|
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;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
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;
|
|
fcntl(sock->fd, F_SETFL, fl);
|
|
}
|
|
|
|
ret = register_poll(sock, flags);
|
|
if (ret < 0)
|
|
goto out;
|
|
|
|
sock->registered = true;
|
|
sock->eof = false;
|
|
sock->error = false;
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
int uloop_fd_delete(struct uloop_fd *fd)
|
|
{
|
|
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;
|
|
|
|
fd->registered = false;
|
|
uloop_fd_stack_event(fd, -1);
|
|
return __uloop_fd_delete(fd);
|
|
}
|
|
|
|
static void uloop_handle_sigint(int signo)
|
|
{
|
|
uloop_status = signo;
|
|
uloop_cancelled = true;
|
|
}
|
|
|
|
static void uloop_install_handler(int signum, void (*handler)(int), struct sigaction* old, bool add)
|
|
{
|
|
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(bool add)
|
|
{
|
|
static struct sigaction old_sigint, old_sigterm;
|
|
uloop_install_handler(SIGINT, uloop_handle_sigint, &old_sigint, add);
|
|
uloop_install_handler(SIGTERM, uloop_handle_sigint, &old_sigterm, add);
|
|
}
|
|
|
|
int uloop_init(void)
|
|
{
|
|
if (uloop_init_pollfd() < 0)
|
|
return -1;
|
|
uloop_setup_signals(true);
|
|
return 0;
|
|
}
|
|
|
|
int uloop_run(void)
|
|
{
|
|
uloop_status = 0;
|
|
uloop_cancelled = false;
|
|
while (!uloop_cancelled) uloop_run_events(-1);
|
|
return uloop_status;
|
|
}
|
|
|
|
void uloop_done(void)
|
|
{
|
|
uloop_setup_signals(false);
|
|
if (poll_fd >= 0) {
|
|
close(poll_fd);
|
|
poll_fd = -1;
|
|
}
|
|
}
|