src/fdevent_libev.c

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