src/fdevent_libev.c

   1 #include "first.h"
   2
   3 #include <stdlib.h>
   4
   5 #include "fdevent_impl.h"
   6 #include "fdevent.h"
   7 #include "buffer.h"
   8 #include "log.h"
   9
  10 #ifdef FDEVENT_USE_LIBEV
  11
  12 # include <ev.h>
  13
  14 static void io_watcher_cb(struct ev_loop *loop, ev_io *w, int revents) {
  15         fdevents *ev = w->data;
  16         fdevent_handler handler = fdevent_get_handler(ev, w->fd);
  17         void *context = fdevent_get_context(ev, w->fd);
  18         int r = 0;
  19         UNUSED(loop);
  20         if (NULL == handler) return;
  21
  22         if (revents & EV_READ) r |= FDEVENT_IN;
  23         if (revents & EV_WRITE) r |= FDEVENT_OUT;
  24         if (revents & EV_ERROR) r |= FDEVENT_ERR;
  25
  26         switch (r = (*handler)(ev->srv, context, r)) {
  27         case HANDLER_FINISHED:
  28         case HANDLER_GO_ON:
  29         case HANDLER_WAIT_FOR_EVENT:
  30         case HANDLER_WAIT_FOR_FD:
  31                 break;
  32         case HANDLER_ERROR:
  33                 /* should never happen */
  34                 SEGFAULT();
  35                 break;
  36         default:
  37                 log_error_write(ev->srv, __FILE__, __LINE__, "d", r);
  38                 break;
  39         }
  40 }
  41
  42 static void fdevent_libev_free(fdevents *ev) {
  43         UNUSED(ev);
  44 }
  45
  46 static int fdevent_libev_event_del(fdevents *ev, int fde_ndx, int fd) {
  47         fdnode *fdn;
  48         ev_io *watcher;
  49
  50         if (-1 == fde_ndx) return -1;
  51
  52         fdn = ev->fdarray[fd];
  53         watcher = fdn->handler_ctx;
  54
  55         if (!watcher) return -1;
  56
  57         ev_io_stop(ev->libev_loop, watcher);
  58         free(watcher);
  59         fdn->handler_ctx = NULL;
  60
  61         return -1;
  62 }
  63
  64 static int fdevent_libev_event_set(fdevents *ev, int fde_ndx, int fd, int events) {
  65         fdnode *fdn = ev->fdarray[fd];
  66         ev_io *watcher = fdn->handler_ctx;
  67         int ev_events = 0;
  68         UNUSED(fde_ndx);
  69
  70         if (events & FDEVENT_IN)  ev_events |= EV_READ;
  71         if (events & FDEVENT_OUT) ev_events |= EV_WRITE;
  72
  73         if (!watcher) {
  74                 fdn->handler_ctx = watcher = calloc(1, sizeof(ev_io));
  75                 force_assert(watcher);
  76
  77                 ev_io_init(watcher, io_watcher_cb, fd, ev_events);
  78                 watcher->data = ev;
  79                 ev_io_start(ev->libev_loop, watcher);
  80         } else {
  81                 if ((watcher->events & (EV_READ | EV_WRITE)) != ev_events) {
  82                         ev_io_stop(ev->libev_loop, watcher);
  83                         ev_io_set(watcher, watcher->fd, ev_events);
  84                         ev_io_start(ev->libev_loop, watcher);
  85                 }
  86         }
  87
  88         return fd;
  89 }
  90
  91 static void timeout_watcher_cb(struct ev_loop *loop, ev_timer *w, int revents) {
  92         UNUSED(loop);
  93         UNUSED(w);
  94         UNUSED(revents);
  95 }
  96
  97 static ev_timer timeout_watcher;
  98
  99 static int fdevent_libev_poll(fdevents *ev, int timeout_ms) {
 100         timeout_watcher.repeat = (timeout_ms > 0) ? timeout_ms/1000.0 : 0.001;
 101
 102         ev_timer_again(ev->libev_loop, &timeout_watcher);
 103         ev_run(ev->libev_loop, EVRUN_ONCE);
 104
 105         return 0;
 106 }
 107
 108 static int fdevent_libev_event_get_revent(fdevents *ev, size_t ndx) {
 109         UNUSED(ev);
 110         UNUSED(ndx);
 111
 112         return 0;
 113 }
 114
 115 static int fdevent_libev_event_get_fd(fdevents *ev, size_t ndx) {
 116         UNUSED(ev);
 117         UNUSED(ndx);
 118
 119         return -1;
 120 }
 121
 122 static int fdevent_libev_event_next_fdndx(fdevents *ev, int ndx) {
 123         UNUSED(ev);
 124         UNUSED(ndx);
 125
 126         return -1;
 127 }
 128
 129 static int fdevent_libev_reset(fdevents *ev) {
 130         UNUSED(ev);
 131
 132         ev_default_fork();
 133
 134         return 0;
 135 }
 136
 137 int fdevent_libev_init(fdevents *ev) {
 138         struct ev_timer * const timer = &timeout_watcher;
 139         memset(timer, 0, sizeof(*timer));
 140
 141         ev->type = FDEVENT_HANDLER_LIBEV;
 142 #define SET(x) \
 143         ev->x = fdevent_libev_##x;
 144
 145         SET(free);
 146         SET(poll);
 147         SET(reset);
 148
 149         SET(event_del);
 150         SET(event_set);
 151
 152         SET(event_next_fdndx);
 153         SET(event_get_fd);
 154         SET(event_get_revent);
 155
 156         if (NULL == (ev->libev_loop = ev_default_loop(0))) {
 157                 log_error_write(ev->srv, __FILE__, __LINE__, "S",
 158                         "ev_default_loop failed , try to set server.event-handler = \"poll\" or \"select\"");
 159
 160                 return -1;
 161         }
 162
 163         ev_timer_init(timer, timeout_watcher_cb, 0.0, 1.0);
 164
 165         return 0;
 166 }
 167
 168 #else
 169 int fdevent_libev_init(fdevents *ev) {
 170         UNUSED(ev);
 171
 172         log_error_write(ev->srv, __FILE__, __LINE__, "S",
 173                 "libev not supported, try to set server.event-handler = \"poll\" or \"select\"");
 174
 175         return -1;
 176 }
 177 #endif