Return to fdevent_libev.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src

lighttpd 1.4.41

    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: 
   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: 
  102: 	return 0;
  103: }
  104: 
  105: static int fdevent_libev_event_get_revent(fdevents *ev, size_t ndx) {
  106: 	UNUSED(ev);
  107: 	UNUSED(ndx);
  108: 
  109: 	return 0;
  110: }
  111: 
  112: static int fdevent_libev_event_get_fd(fdevents *ev, size_t ndx) {
  113: 	UNUSED(ev);
  114: 	UNUSED(ndx);
  115: 
  116: 	return -1;
  117: }
  118: 
  119: static int fdevent_libev_event_next_fdndx(fdevents *ev, int ndx) {
  120: 	UNUSED(ev);
  121: 	UNUSED(ndx);
  122: 
  123: 	return -1;
  124: }
  125: 
  126: static int fdevent_libev_reset(fdevents *ev) {
  127: 	UNUSED(ev);
  128: 
  129: 	ev_default_fork();
  130: 
  131: 	return 0;
  132: }
  133: 
  134: int fdevent_libev_init(fdevents *ev) {
  135: 	struct ev_timer * const timer = &timeout_watcher;
  136: 
  137: 	ev->type = FDEVENT_HANDLER_LIBEV;
  138: #define SET(x) \
  139: 	ev->x = fdevent_libev_##x;
  140: 
  141: 	SET(free);
  142: 	SET(poll);
  143: 	SET(reset);
  144: 
  145: 	SET(event_del);
  146: 	SET(event_set);
  147: 
  148: 	SET(event_next_fdndx);
  149: 	SET(event_get_fd);
  150: 	SET(event_get_revent);
  151: 
  152: 	if (NULL == (ev->libev_loop = ev_default_loop(0))) {
  153: 		log_error_write(ev->srv, __FILE__, __LINE__, "S",
  154: 			"ev_default_loop failed , try to set server.event-handler = \"poll\" or \"select\"");
  155: 
  156: 		return -1;
  157: 	}
  158: 
  159: 	ev_timer_init(timer, timeout_watcher_cb, 0.0, 1.0);
  160: 
  161: 	return 0;
  162: }
  163: 
  164: #else
  165: int fdevent_libev_init(fdevents *ev) {
  166: 	UNUSED(ev);
  167: 
  168: 	log_error_write(ev->srv, __FILE__, __LINE__, "S",
  169: 		"libev not supported, try to set server.event-handler = \"poll\" or \"select\"");
  170: 
  171: 	return -1;
  172: }
  173: #endif