ustream: prevent recursive calls to the read callback

[project/libubox.git] / uloop-epoll.c

diff --git a/uloop-epoll.c b/uloop-epoll.c
index 9581e124040c91514f5cee0ec1a5d7800cfd1edd..d7b3acf095c467edbed832007e708617ef99108c 100644 (file)
--- a/uloop-epoll.c
+++ b/uloop-epoll.c
@@ -16,8 +16,6 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include <sys/signalfd.h>
-
 /**
  * FIXME: uClibc < 0.9.30.3 does not define EPOLLRDHUP for Linux >= 2.6.17
  */
@@ -25,63 +23,8 @@
 #define EPOLLRDHUP 0x2000
 #endif
 
-static void
-uloop_signal_fd_cb(struct uloop_fd *fd, unsigned int events)
-{
-       struct signalfd_siginfo fdsi;
-       int ret;
-
-retry:
-       ret = read(fd->fd, &fdsi, sizeof(fdsi));
-       if (ret < 0 && errno == EINTR)
-               goto retry;
-
-       if (ret != sizeof(fdsi))
-               return;
-
-       uloop_handle_signal(fdsi.ssi_signo);
-}
-
-static bool
-uloop_setup_signalfd(bool add)
+static int uloop_init_pollfd(void)
 {
-       static struct uloop_fd sfd = {
-               .cb = uloop_signal_fd_cb
-       };
-       static sigset_t prev_mask;
-       sigset_t mask;
-
-       if (signal_fd < 0)
-               return false;
-
-       sigemptyset(&mask);
-
-       if (!add) {
-               uloop_fd_delete(&sfd);
-               sigprocmask(SIG_BLOCK, &prev_mask, NULL);
-       } else {
-               sigaddset(&mask, SIGQUIT);
-               sigaddset(&mask, SIGINT);
-               sigaddset(&mask, SIGTERM);
-               sigaddset(&mask, SIGCHLD);
-               sigprocmask(SIG_BLOCK, &mask, &prev_mask);
-
-               sfd.fd = signal_fd;
-               uloop_fd_add(&sfd, ULOOP_READ | ULOOP_EDGE_TRIGGER);
-       }
-
-       if (signalfd(signal_fd, &mask, SFD_NONBLOCK | SFD_CLOEXEC) < 0) {
-               sigprocmask(SIG_BLOCK, &prev_mask, NULL);
-               return false;
-       }
-
-       return true;
-}
-
-int uloop_init(void)
-{
-       sigset_t mask;
-
        if (poll_fd >= 0)
                return 0;
 
@@ -90,10 +33,6 @@ int uloop_init(void)
                return -1;
 
        fcntl(poll_fd, F_SETFD, fcntl(poll_fd, F_GETFD) | FD_CLOEXEC);
-
-       sigemptyset(&mask);
-       signal_fd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
-
        return 0;
 }
 
@@ -113,9 +52,7 @@ static int register_poll(struct uloop_fd *fd, unsigned int flags)
        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);
 }
@@ -167,3 +104,83 @@ static int uloop_fetch_events(int timeout)
 
        return nfds;
 }
+
+static void dispatch_timer(struct uloop_fd *u, unsigned int events)
+{
+       if (!(events & ULOOP_READ))
+               return;
+
+       uint64_t fired;
+
+       if (read(u->fd, &fired, sizeof(fired)) != sizeof(fired))
+               return;
+
+       struct uloop_interval *tm = container_of(u, struct uloop_interval, priv.ufd);
+
+       tm->expirations += fired;
+       tm->cb(tm);
+}
+
+static int timer_register(struct uloop_interval *tm, unsigned int msecs)
+{
+       if (!tm->priv.ufd.registered) {
+               int fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC|TFD_NONBLOCK);
+
+               if (fd == -1)
+                       return -1;
+
+               tm->priv.ufd.fd = fd;
+               tm->priv.ufd.cb = dispatch_timer;
+       }
+
+       struct itimerspec spec = {
+               .it_value = {
+                       .tv_sec = msecs / 1000,
+                       .tv_nsec = (msecs % 1000) * 1000000
+               },
+               .it_interval = {
+                       .tv_sec = msecs / 1000,
+                       .tv_nsec = (msecs % 1000) * 1000000
+               }
+       };
+
+       if (timerfd_settime(tm->priv.ufd.fd, 0, &spec, NULL) == -1)
+               goto err;
+
+       if (uloop_fd_add(&tm->priv.ufd, ULOOP_READ) == -1)
+               goto err;
+
+       return 0;
+
+err:
+       uloop_fd_delete(&tm->priv.ufd);
+       close(tm->priv.ufd.fd);
+       memset(&tm->priv.ufd, 0, sizeof(tm->priv.ufd));
+
+       return -1;
+}
+
+static int timer_remove(struct uloop_interval *tm)
+{
+       int ret = __uloop_fd_delete(&tm->priv.ufd);
+
+       if (ret == 0) {
+               close(tm->priv.ufd.fd);
+               memset(&tm->priv.ufd, 0, sizeof(tm->priv.ufd));
+       }
+
+       return ret;
+}
+
+static int64_t timer_next(struct uloop_interval *tm)
+{
+       struct itimerspec spec;
+
+       if (!tm->priv.ufd.registered)
+               return -1;
+
+       if (timerfd_gettime(tm->priv.ufd.fd, &spec) == -1)
+               return -1;
+
+       return spec.it_value.tv_sec * 1000 + spec.it_value.tv_nsec / 1000000;
+}