1 /* 2 * This file and its contents are supplied under the terms of the 3 * Common Development and Distribution License ("CDDL"), version 1.0. 4 * You may only use this file in accordance with the terms of version 5 * 1.0 of the CDDL. 6 * 7 * A full copy of the text of the CDDL should have accompanied this 8 * source. A copy of the CDDL is also available via the Internet at 9 * http://www.illumos.org/license/CDDL. 10 */ 11 12 /* 13 * Copyright 2016 Joyent, Inc. 14 */ 15 16 #include <sys/types.h> 17 #include <sys/epoll.h> 18 #include <sys/devpoll.h> 19 #include <unistd.h> 20 #include <errno.h> 21 #include <fcntl.h> 22 #include <poll.h> 23 24 /* 25 * Events that match their epoll(7) equivalents. 26 */ 27 #if EPOLLIN != POLLIN 28 #error value of EPOLLIN does not match value of POLLIN 29 #endif 30 31 #if EPOLLPRI != POLLPRI 32 #error value of EPOLLPRI does not match value of POLLPRI 33 #endif 34 35 #if EPOLLOUT != POLLOUT 36 #error value of EPOLLOUT does not match value of POLLOUT 37 #endif 38 39 #if EPOLLRDNORM != POLLRDNORM 40 #error value of EPOLLRDNORM does not match value of POLLRDNORM 41 #endif 42 43 #if EPOLLRDBAND != POLLRDBAND 44 #error value of EPOLLRDBAND does not match value of POLLRDBAND 45 #endif 46 47 #if EPOLLERR != POLLERR 48 #error value of EPOLLERR does not match value of POLLERR 49 #endif 50 51 #if EPOLLHUP != POLLHUP 52 #error value of EPOLLHUP does not match value of POLLHUP 53 #endif 54 55 /* 56 * Events that we ignore entirely. They can be set in events, but they will 57 * never be returned. 58 */ 59 #define EPOLLIGNORED (EPOLLMSG | EPOLLWAKEUP) 60 61 /* 62 * Events that we swizzle into other bit positions. 63 */ 64 #define EPOLLSWIZZLED \ 65 (EPOLLRDHUP | EPOLLONESHOT | EPOLLET | EPOLLWRBAND | EPOLLWRNORM) 66 67 int 68 epoll_create(int size) 69 { 70 int fd; 71 72 /* 73 * From the epoll_create() man page: "Since Linux 2.6.8, the size 74 * argument is ignored, but must be greater than zero." You keep using 75 * that word "ignored"... 76 */ 77 if (size <= 0) { 78 errno = EINVAL; 79 return (-1); 80 } 81 82 if ((fd = open("/dev/poll", O_RDWR)) == -1) 83 return (-1); 84 85 if (ioctl(fd, DP_EPOLLCOMPAT, 0) == -1) { 86 (void) close(fd); 87 return (-1); 88 } 89 90 return (fd); 91 } 92 93 int 94 epoll_create1(int flags) 95 { 96 int fd, oflags = O_RDWR; 97 98 if (flags & EPOLL_CLOEXEC) 99 oflags |= O_CLOEXEC; 100 101 if ((fd = open("/dev/poll", oflags)) == -1) 102 return (-1); 103 104 if (ioctl(fd, DP_EPOLLCOMPAT, 0) == -1) { 105 (void) close(fd); 106 return (-1); 107 } 108 109 return (fd); 110 } 111 112 int 113 epoll_ctl(int epfd, int op, int fd, struct epoll_event *event) 114 { 115 dvpoll_epollfd_t epoll[2]; 116 uint32_t events, ev = 0; 117 int i = 0, res; 118 119 epoll[i].dpep_pollfd.fd = fd; 120 121 switch (op) { 122 case EPOLL_CTL_DEL: 123 ev = POLLREMOVE; 124 break; 125 126 case EPOLL_CTL_MOD: 127 /* 128 * In the modify case, we pass down two events: one to 129 * remove the event and another to add it back. 130 */ 131 epoll[i++].dpep_pollfd.events = POLLREMOVE; 132 epoll[i].dpep_pollfd.fd = fd; 133 /* FALLTHROUGH */ 134 135 case EPOLL_CTL_ADD: 136 /* 137 * Mask off the events that we ignore, and then swizzle the 138 * events for which our values differ from their epoll(7) 139 * equivalents. 140 */ 141 events = event->events; 142 ev = events & ~(EPOLLIGNORED | EPOLLSWIZZLED); 143 144 if (events & EPOLLRDHUP) 145 ev |= POLLRDHUP; 146 147 if (events & EPOLLET) 148 ev |= POLLET; 149 150 if (events & EPOLLONESHOT) 151 ev |= POLLONESHOT; 152 153 if (events & EPOLLWRNORM) 154 ev |= POLLWRNORM; 155 156 if (events & EPOLLWRBAND) 157 ev |= POLLWRBAND; 158 159 epoll[i].dpep_data = event->data.u64; 160 break; 161 162 default: 163 errno = EOPNOTSUPP; 164 return (-1); 165 } 166 167 epoll[i].dpep_pollfd.events = ev; 168 retry: 169 res = write(epfd, epoll, sizeof (epoll[0]) * (i + 1)); 170 171 if (res == -1) { 172 if (errno == EINTR) { 173 /* 174 * Linux does not document EINTR as an allowed error 175 * for epoll_ctl. The write must be retried if it is 176 * not done automatically via SA_RESTART. 177 */ 178 goto retry; 179 } 180 if (errno == ELOOP) { 181 /* 182 * Convert the specific /dev/poll error about an fd 183 * loop into what is expected from the Linux epoll 184 * interface. 185 */ 186 errno = EINVAL; 187 } 188 return (-1); 189 } 190 return (0); 191 } 192 193 int 194 epoll_wait(int epfd, struct epoll_event *events, 195 int maxevents, int timeout) 196 { 197 struct dvpoll arg; 198 199 if (maxevents <= 0) { 200 errno = EINVAL; 201 return (-1); 202 } 203 204 arg.dp_nfds = maxevents; 205 arg.dp_timeout = timeout; 206 arg.dp_fds = (pollfd_t *)events; 207 208 return (ioctl(epfd, DP_POLL, &arg)); 209 } 210 211 int 212 epoll_pwait(int epfd, struct epoll_event *events, 213 int maxevents, int timeout, const sigset_t *sigmask) 214 { 215 struct dvpoll arg; 216 217 if (maxevents <= 0) { 218 errno = EINVAL; 219 return (-1); 220 } 221 222 arg.dp_nfds = maxevents; 223 arg.dp_timeout = timeout; 224 arg.dp_fds = (pollfd_t *)events; 225 arg.dp_setp = (sigset_t *)sigmask; 226 227 return (ioctl(epfd, DP_PPOLL, &arg)); 228 } 229