xref: /illumos-gate/usr/src/lib/libc/port/sys/epoll.c (revision bbf21555)

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2017 Joyent, Inc.
 * Copyright 2020 Oxide Computer Company
 */

#include <sys/types.h>
#include <sys/epoll.h>
#include <sys/devpoll.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <poll.h>

/*
 * Events that match their epoll(7) equivalents.
 */
#if EPOLLIN != POLLIN
#error value of EPOLLIN does not match value of POLLIN
#endif

#if EPOLLPRI != POLLPRI
#error value of EPOLLPRI does not match value of POLLPRI
#endif

#if EPOLLOUT != POLLOUT
#error value of EPOLLOUT does not match value of POLLOUT
#endif

#if EPOLLRDNORM != POLLRDNORM
#error value of EPOLLRDNORM does not match value of POLLRDNORM
#endif

#if EPOLLRDBAND != POLLRDBAND
#error value of EPOLLRDBAND does not match value of POLLRDBAND
#endif

#if EPOLLERR != POLLERR
#error value of EPOLLERR does not match value of POLLERR
#endif

#if EPOLLHUP != POLLHUP
#error value of EPOLLHUP does not match value of POLLHUP
#endif

/*
 * Events that we ignore entirely.  They can be set in events, but they will
 * never be returned.
 */
#define	EPOLLIGNORED	(EPOLLMSG | EPOLLWAKEUP | EPOLLEXCLUSIVE)

/*
 * Events that we swizzle into other bit positions.
 */
#define	EPOLLSWIZZLED	\
	(EPOLLRDHUP | EPOLLONESHOT | EPOLLET | EPOLLWRBAND | EPOLLWRNORM)

/*
 * The defined behavior for epoll_wait/epoll_pwait when using a timeout less
 * than 0 is to wait for events until they arrive (or interrupted by a signal).
 * While poll(4D) operates in this manner for a timeout of -1, using other
 * negative values results in an immediate timeout, as if it had been set to 0.
 * For that reason, negative values are clamped to -1.
 */
#define	EPOLL_TIMEOUT_CLAMP(t)	(((t) < -1) ? -1 : (t))

int
epoll_create(int size)
{
	int fd;

	/*
	 * From the epoll_create() man page:  "Since Linux 2.6.8, the size
	 * argument is ignored, but must be greater than zero."  You keep using
	 * that word "ignored"...
	 */
	if (size <= 0) {
		errno = EINVAL;
		return (-1);
	}

	if ((fd = open("/dev/poll", O_RDWR)) == -1)
		return (-1);

	if (ioctl(fd, DP_EPOLLCOMPAT, 0) == -1) {
		(void) close(fd);
		return (-1);
	}

	return (fd);
}

int
epoll_create1(int flags)
{
	int fd, oflags = O_RDWR;

	if (flags & EPOLL_CLOEXEC) {
		oflags |= O_CLOEXEC;
		flags ^= EPOLL_CLOEXEC;
	}
	/* Reject unrecognized flags */
	if (flags != 0) {
		errno = EINVAL;
		return (-1);
	}

	if ((fd = open("/dev/poll", oflags)) == -1)
		return (-1);

	if (ioctl(fd, DP_EPOLLCOMPAT, 0) == -1) {
		(void) close(fd);
		return (-1);
	}

	return (fd);
}

int
epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
{
	dvpoll_epollfd_t epoll[2];
	uint32_t events, ev = 0;
	int i = 0, res;

	epoll[i].dpep_pollfd.fd = fd;

	switch (op) {
	case EPOLL_CTL_DEL:
		ev = POLLREMOVE;
		break;

	case EPOLL_CTL_MOD:
		/* EPOLLEXCLUSIVE is prohibited for modify operations */
		if ((event->events & EPOLLEXCLUSIVE) != 0) {
			errno = EINVAL;
			return (-1);
		}
		/*
		 * In the modify case, we pass down two events:  one to
		 * remove the event and another to add it back.
		 */
		epoll[i++].dpep_pollfd.events = POLLREMOVE;
		epoll[i].dpep_pollfd.fd = fd;
		/* FALLTHROUGH */

	case EPOLL_CTL_ADD:
		/*
		 * Mask off the events that we ignore, and then swizzle the
		 * events for which our values differ from their epoll(7)
		 * equivalents.
		 */
		events = event->events;
		ev = events & ~(EPOLLIGNORED | EPOLLSWIZZLED);

		if (events & EPOLLRDHUP)
			ev |= POLLRDHUP;

		if (events & EPOLLET)
			ev |= POLLET;

		if (events & EPOLLONESHOT)
			ev |= POLLONESHOT;

		if (events & EPOLLWRNORM)
			ev |= POLLWRNORM;

		if (events & EPOLLWRBAND)
			ev |= POLLWRBAND;

		epoll[i].dpep_data = event->data.u64;
		break;

	default:
		errno = EOPNOTSUPP;
		return (-1);
	}

	epoll[i].dpep_pollfd.events = ev;
retry:
	res = write(epfd, epoll, sizeof (epoll[0]) * (i + 1));

	if (res == -1) {
		if (errno == EINTR) {
			/*
			 * Linux does not document EINTR as an allowed error
			 * for epoll_ctl.  The write must be retried if it is
			 * not done automatically via SA_RESTART.
			 */
			goto retry;
		}
		if (errno == ELOOP) {
			/*
			 * Convert the specific /dev/poll error about an fd
			 * loop into what is expected from the Linux epoll
			 * interface.
			 */
			errno = EINVAL;
		}
		return (-1);
	}
	return (0);
}

int
epoll_wait(int epfd, struct epoll_event *events,
    int maxevents, int timeout)
{
	struct dvpoll arg;

	if (maxevents <= 0) {
		errno = EINVAL;
		return (-1);
	}

	arg.dp_nfds = maxevents;
	arg.dp_timeout = EPOLL_TIMEOUT_CLAMP(timeout);
	arg.dp_fds = (pollfd_t *)events;

	return (ioctl(epfd, DP_POLL, &arg));
}

int
epoll_pwait(int epfd, struct epoll_event *events,
    int maxevents, int timeout, const sigset_t *sigmask)
{
	struct dvpoll arg;

	if (maxevents <= 0) {
		errno = EINVAL;
		return (-1);
	}

	arg.dp_nfds = maxevents;
	arg.dp_timeout = EPOLL_TIMEOUT_CLAMP(timeout);
	arg.dp_fds = (pollfd_t *)events;
	arg.dp_setp = (sigset_t *)sigmask;

	return (ioctl(epfd, DP_PPOLL, &arg));
}