Return to fdevent_solaris_devpoll.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 <sys/types.h>
    8: 
    9: #include <unistd.h>
   10: #include <stdlib.h>
   11: #include <stdio.h>
   12: #include <string.h>
   13: #include <errno.h>
   14: #include <signal.h>
   15: #include <fcntl.h>
   16: 
   17: #ifdef USE_SOLARIS_DEVPOLL
   18: 
   19: # include <sys/devpoll.h>
   20: 
   21: static void fdevent_solaris_devpoll_free(fdevents *ev) {
   22: 	free(ev->devpollfds);
   23: 	close(ev->devpoll_fd);
   24: }
   25: 
   26: /* return -1 is fine here */
   27: 
   28: static int fdevent_solaris_devpoll_event_del(fdevents *ev, int fde_ndx, int fd) {
   29: 	struct pollfd pfd;
   30: 
   31: 	if (fde_ndx < 0) return -1;
   32: 
   33: 	pfd.fd = fd;
   34: 	pfd.events = POLLREMOVE;
   35: 	pfd.revents = 0;
   36: 
   37: 	if (-1 == write(ev->devpoll_fd, &pfd, sizeof(pfd))) {
   38: 		log_error_write(ev->srv, __FILE__, __LINE__, "S(D, S)",
   39: 			"(del) write failed: ", fd, strerror(errno));
   40: 
   41: 		return -1;
   42: 	}
   43: 
   44: 	return -1;
   45: }
   46: 
   47: static int fdevent_solaris_devpoll_event_set(fdevents *ev, int fde_ndx, int fd, int events) {
   48: 	struct pollfd pfd;
   49: 	int add = 0;
   50: 
   51: 	int pevents = 0;
   52: 	if (events & FDEVENT_IN)  pevents |= POLLIN;
   53: 	if (events & FDEVENT_OUT) pevents |= POLLOUT;
   54: 
   55: 	if (fde_ndx == -1) add = 1;
   56: 
   57: 	pfd.fd = fd;
   58: 	pfd.events = pevents;
   59: 	pfd.revents = 0;
   60: 
   61: 	if (-1 == write(ev->devpoll_fd, &pfd, sizeof(pfd))) {
   62: 		log_error_write(ev->srv, __FILE__, __LINE__, "S(D, S)",
   63: 			"(set) write failed: ", fd, strerror(errno));
   64: 
   65: 		return -1;
   66: 	}
   67: 
   68: 	return fd;
   69: }
   70: 
   71: static int fdevent_solaris_devpoll_poll(fdevents *ev, int timeout_ms) {
   72: 	struct dvpoll dopoll;
   73: 	int ret;
   74: 
   75: 	dopoll.dp_timeout = timeout_ms;
   76: 	dopoll.dp_nfds = ev->maxfds - 1;
   77: 	dopoll.dp_fds = ev->devpollfds;
   78: 
   79: 	ret = ioctl(ev->devpoll_fd, DP_POLL, &dopoll);
   80: 
   81: 	return ret;
   82: }
   83: 
   84: static int fdevent_solaris_devpoll_event_get_revent(fdevents *ev, size_t ndx) {
   85: 	int r, poll_r;
   86: 
   87: 	r = 0;
   88: 	poll_r = ev->devpollfds[ndx].revents;
   89: 
   90: 	/* map POLL* to FDEVEN_*; they are probably the same, but still. */
   91: 
   92: 	if (poll_r & POLLIN) r |= FDEVENT_IN;
   93: 	if (poll_r & POLLOUT) r |= FDEVENT_OUT;
   94: 	if (poll_r & POLLERR) r |= FDEVENT_ERR;
   95: 	if (poll_r & POLLHUP) r |= FDEVENT_HUP;
   96: 	if (poll_r & POLLNVAL) r |= FDEVENT_NVAL;
   97: 	if (poll_r & POLLPRI) r |= FDEVENT_PRI;
   98: 
   99: 	return r;
  100: }
  101: 
  102: static int fdevent_solaris_devpoll_event_get_fd(fdevents *ev, size_t ndx) {
  103: 	return ev->devpollfds[ndx].fd;
  104: }
  105: 
  106: static int fdevent_solaris_devpoll_event_next_fdndx(fdevents *ev, int last_ndx) {
  107: 	size_t i;
  108: 
  109: 	UNUSED(ev);
  110: 
  111: 	i = (last_ndx < 0) ? 0 : last_ndx + 1;
  112: 
  113: 	return i;
  114: }
  115: 
  116: int fdevent_solaris_devpoll_reset(fdevents *ev) {
  117: 	/* a forked process does only inherit the filedescriptor,
  118: 	 * but every operation on the device will lead to a EACCES */
  119: 	if ((ev->devpoll_fd = open("/dev/poll", O_RDWR)) < 0) {
  120: 		log_error_write(ev->srv, __FILE__, __LINE__, "SSS",
  121: 			"opening /dev/poll failed (", strerror(errno), "), try to set server.event-handler = \"poll\" or \"select\"");
  122: 
  123: 		return -1;
  124: 	}
  125: 
  126: 	fd_close_on_exec(ev->devpoll_fd);
  127: 	return 0;
  128: }
  129: int fdevent_solaris_devpoll_init(fdevents *ev) {
  130: 	ev->type = FDEVENT_HANDLER_SOLARIS_DEVPOLL;
  131: #define SET(x) \
  132: 	ev->x = fdevent_solaris_devpoll_##x;
  133: 
  134: 	SET(free);
  135: 	SET(poll);
  136: 	SET(reset);
  137: 
  138: 	SET(event_del);
  139: 	SET(event_set);
  140: 
  141: 	SET(event_next_fdndx);
  142: 	SET(event_get_fd);
  143: 	SET(event_get_revent);
  144: 
  145: 	ev->devpollfds = malloc(sizeof(*ev->devpollfds) * ev->maxfds);
  146: 	force_assert(NULL != ev->devpollfds);
  147: 
  148: 	if ((ev->devpoll_fd = open("/dev/poll", O_RDWR)) < 0) {
  149: 		log_error_write(ev->srv, __FILE__, __LINE__, "SSS",
  150: 			"opening /dev/poll failed (", strerror(errno), "), try to set server.event-handler = \"poll\" or \"select\"");
  151: 
  152: 		return -1;
  153: 	}
  154: 
  155: 	/* we just wanted to check if it works */
  156: 	close(ev->devpoll_fd);
  157: 
  158: 	ev->devpoll_fd = -1;
  159: 
  160: 	return 0;
  161: }
  162: 
  163: #else
  164: int fdevent_solaris_devpoll_init(fdevents *ev) {
  165: 	UNUSED(ev);
  166: 
  167: 	log_error_write(ev->srv, __FILE__, __LINE__, "S",
  168: 		"solaris-devpoll not supported, try to set server.event-handler = \"poll\" or \"select\"");
  169: 
  170: 	return -1;
  171: }
  172: #endif