src/fdevent_libev.c

   1 #include "first.h"
   2
   3 #include "fdevent.h"
   4 #include "buffer.h"
   5 #include "log.h"
   6
   7 #include <assert.h>
   8
   9 #ifdef USE_LIBEV
  10
  11 # include <ev.h>
  12
  13 static void io_watcher_cb(struct ev_loop *loop, ev_io *w, int revents) {
  14         fdevents *ev = w->data;
  15         fdnode *fdn = ev->fdarray[w->fd];
  16         int r = 0;
  17         UNUSED(loop);
  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 = (*fdn->handler)(ev->srv, fdn->ctx, 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         ev_timer_stop(loop, w);
  94 }
  95
  96
  97 static int fdevent_libev_poll(fdevents *ev, int timeout_ms) {
  98         union {
  99                 struct ev_watcher w;
 100                 struct ev_timer timer;
 101         } timeout_watcher;
 102
 103         if (!timeout_ms) timeout_ms = 1;
 104
 105         ev_init(&timeout_watcher.w, NULL);
 106         ev_set_cb(&timeout_watcher.timer, timeout_watcher_cb);
 107         timeout_watcher.timer.repeat = ((ev_tstamp) timeout_ms)/1000.0;
 108         force_assert(timeout_watcher.timer.repeat);
 109         ev_timer_again(ev->libev_loop, &timeout_watcher.timer);
 110
 111         ev_loop(ev->libev_loop, EVLOOP_ONESHOT);
 112
 113         ev_timer_stop(ev->libev_loop, &timeout_watcher.timer);
 114
 115         return 0;
 116 }
 117
 118 static int fdevent_libev_event_get_revent(fdevents *ev, size_t ndx) {
 119         UNUSED(ev);
 120         UNUSED(ndx);
 121
 122         return 0;
 123 }
 124
 125 static int fdevent_libev_event_get_fd(fdevents *ev, size_t ndx) {
 126         UNUSED(ev);
 127         UNUSED(ndx);
 128
 129         return -1;
 130 }
 131
 132 static int fdevent_libev_event_next_fdndx(fdevents *ev, int ndx) {
 133         UNUSED(ev);
 134         UNUSED(ndx);
 135
 136         return -1;
 137 }
 138
 139 static int fdevent_libev_reset(fdevents *ev) {
 140         UNUSED(ev);
 141
 142         ev_default_fork();
 143
 144         return 0;
 145 }
 146
 147 int fdevent_libev_init(fdevents *ev) {
 148         ev->type = FDEVENT_HANDLER_LIBEV;
 149 #define SET(x) \
 150         ev->x = fdevent_libev_##x;
 151
 152         SET(free);
 153         SET(poll);
 154         SET(reset);
 155
 156         SET(event_del);
 157         SET(event_set);
 158
 159         SET(event_next_fdndx);
 160         SET(event_get_fd);
 161         SET(event_get_revent);
 162
 163         if (NULL == (ev->libev_loop = ev_default_loop(0))) {
 164                 log_error_write(ev->srv, __FILE__, __LINE__, "S",
 165                         "ev_default_loop failed , try to set server.event-handler = \"poll\" or \"select\"");
 166
 167                 return -1;
 168         }
 169
 170         return 0;
 171 }
 172
 173 #else
 174 int fdevent_libev_init(fdevents *ev) {
 175         UNUSED(ev);
 176
 177         log_error_write(ev->srv, __FILE__, __LINE__, "S",
 178                 "libev not supported, try to set server.event-handler = \"poll\" or \"select\"");
 179
 180         return -1;
 181 }
 182 #endif