Unmap pages mapped during a failed fill_vmr()
[akaros.git] / user / iplib / epoll.c
1 /* Copyright (c) 2015 Google Inc.
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * Epoll, built on FD taps, CEQs, and blocking uthreads on event queues.
6  *
7  * TODO: There are a few incompatibilities with Linux's epoll, some of which are
8  * artifacts of the implementation, and other issues:
9  * - you can't epoll on an epoll fd (or any user fd).  you can only epoll on a
10  * kernel FD that accepts your FD taps.
11  * - there's no EPOLLONESHOT or level-triggered support.
12  * - you can only tap one FD at a time, so you can't add the same FD to
13  * multiple epoll sets.
14  * - closing the epoll is a little dangerous, if there are outstanding INDIR
15  * events.  this will only pop up if you're yielding cores, maybe getting
16  * preempted, and are unlucky.
17  * - epoll_create1 does not support CLOEXEC.  That'd need some work in glibc's
18  * exec and flags in struct user_fd.
19  * - EPOLL_CTL_MOD is just a DEL then an ADD.  There might be races associated
20  * with that.
21  * - epoll_pwait is probably racy.
22  * - You can't dup an epoll fd (same as other user FDs).
23  * - If you add a BSD socket FD to an epoll set, you'll get taps on both the
24  * data FD and the listen FD.
25  * - If you add the same BSD socket listener to multiple epoll sets, you will
26  * likely fail.  This is in addition to being able to tap only one FD at a
27  * time.
28  * */
29
30 #include <sys/epoll.h>
31 #include <parlib/parlib.h>
32 #include <parlib/event.h>
33 #include <parlib/ceq.h>
34 #include <parlib/uthread.h>
35 #include <parlib/timing.h>
36 #include <parlib/slab.h>
37 #include <parlib/assert.h>
38 #include <sys/user_fd.h>
39 #include <sys/close_cb.h>
40 #include <stdio.h>
41 #include <errno.h>
42 #include <unistd.h>
43 #include <malloc.h>
44 #include <sys/queue.h>
45 #include <sys/plan9_helpers.h>
46 #include <ros/fs.h>
47
48 /* Sanity check, so we can ID our own FDs */
49 #define EPOLL_UFD_MAGIC                 0xe9011
50
51 /* Each waiter that uses a timeout will have its own structure for dealing with
52  * its timeout.
53  *
54  * TODO: (RCU/SLAB) it's not safe to reap the objects, until we sort out
55  * INDIRs and RCU-style grace periods.  Not a big deal, since the number of
56  * these is the number of threads that concurrently do epoll timeouts. */
57 struct ep_alarm {
58         struct event_queue              *alarm_evq;
59         struct syscall                  sysc;
60 };
61
62 static struct kmem_cache *ep_alarms_cache;
63
64 struct epoll_ctlr {
65         TAILQ_ENTRY(epoll_ctlr)         link;
66         struct event_queue              *ceq_evq;
67         uth_mutex_t                     *mtx;
68         struct user_fd                  ufd;
69 };
70
71 TAILQ_HEAD(epoll_ctlrs, epoll_ctlr);
72 static struct epoll_ctlrs all_ctlrs = TAILQ_HEAD_INITIALIZER(all_ctlrs);
73 static uth_mutex_t *ctlrs_mtx;
74
75 /* There's some bookkeeping we need to maintain on every FD.  Right now, the FD
76  * is the index into the CEQ event array, so we can just hook this into the user
77  * data blob in the ceq_event.
78  *
79  * If we ever do not maintain a 1:1 mapping from FDs to CEQ IDs, we can use this
80  * to track the CEQ ID and FD. */
81 struct ep_fd_data {
82         struct epoll_event              ep_event;
83         int                             fd;
84         int                             filter;
85 };
86
87 /* Converts epoll events to FD taps. */
88 static int ep_events_to_taps(uint32_t ep_ev)
89 {
90         int taps = 0;
91
92         if (ep_ev & EPOLLIN)
93                 taps |= FDTAP_FILT_READABLE;
94         if (ep_ev & EPOLLOUT)
95                 taps |= FDTAP_FILT_WRITABLE;
96         if (ep_ev & EPOLLRDHUP)
97                 taps |= FDTAP_FILT_RDHUP;
98         if (ep_ev & EPOLLPRI)
99                 taps |= FDTAP_FILT_PRIORITY;
100         if (ep_ev & EPOLLERR)
101                 taps |= FDTAP_FILT_ERROR;
102         if (ep_ev & EPOLLHUP)
103                 taps |= FDTAP_FILT_HANGUP;
104         return taps;
105 }
106
107 /* Converts corresponding FD Taps to epoll events.  There are other taps that do
108  * not make sense for epoll. */
109 static uint32_t taps_to_ep_events(int taps)
110 {
111         uint32_t ep_ev = 0;
112
113         if (taps & FDTAP_FILT_READABLE)
114                 ep_ev |= EPOLLIN;
115         if (taps & FDTAP_FILT_WRITABLE)
116                 ep_ev |= EPOLLOUT;
117         if (taps & FDTAP_FILT_RDHUP)
118                 ep_ev |= EPOLLRDHUP;
119         if (taps & FDTAP_FILT_PRIORITY)
120                 ep_ev |= EPOLLPRI;
121         if (taps & FDTAP_FILT_ERROR)
122                 ep_ev |= EPOLLERR;
123         if (taps & FDTAP_FILT_HANGUP)
124                 ep_ev |= EPOLLHUP;
125         return ep_ev;
126 }
127
128 static unsigned int ep_get_ceq_max_ever(struct epoll_ctlr *ep)
129 {
130         return atomic_read(&ep->ceq_evq->ev_mbox->ceq.max_event_ever);
131 }
132
133 static struct ceq_event *ep_get_ceq_ev(struct epoll_ctlr *ep, size_t idx)
134 {
135         if (ep->ceq_evq->ev_mbox->ceq.nr_events <= idx)
136                 return 0;
137         return &ep->ceq_evq->ev_mbox->ceq.events[idx];
138 }
139
140 static struct epoll_ctlr *fd_to_cltr(int fd)
141 {
142         struct user_fd *ufd = ufd_lookup(fd);
143
144         if (!ufd)
145                 return 0;
146         if (ufd->magic != EPOLL_UFD_MAGIC) {
147                 errno = EBADF;
148                 return 0;
149         }
150         return container_of(ufd, struct epoll_ctlr, ufd);
151 }
152
153 /* Event queue helpers: */
154 static struct event_queue *ep_get_ceq_evq(unsigned int ceq_ring_sz)
155 {
156         struct event_queue *ceq_evq = get_eventq_raw();
157
158         ceq_evq->ev_mbox->type = EV_MBOX_CEQ;
159         ceq_init(&ceq_evq->ev_mbox->ceq, CEQ_OR, NR_FILE_DESC_MAX, ceq_ring_sz);
160         ceq_evq->ev_flags = EVENT_INDIR | EVENT_SPAM_INDIR | EVENT_WAKEUP;
161         evq_attach_wakeup_ctlr(ceq_evq);
162         return ceq_evq;
163 }
164
165 static struct event_queue *ep_get_alarm_evq(void)
166 {
167         /* Don't care about the actual message, just using it for a wakeup */
168         struct event_queue *alarm_evq = get_eventq(EV_MBOX_BITMAP);
169
170         alarm_evq->ev_flags = EVENT_INDIR | EVENT_SPAM_INDIR | EVENT_WAKEUP;
171         evq_attach_wakeup_ctlr(alarm_evq);
172         return alarm_evq;
173 }
174
175 /* Once we've closed our sources of events, we can try to clean up the event
176  * queues.  These are actually dangerous, since there could be INDIRs floating
177  * around for these evqs still, which are basically pointers.  We'll need to run
178  * some sort of user deferred destruction. (TODO). */
179 static void ep_put_ceq_evq(struct event_queue *ceq_evq)
180 {
181 #if 0 /* TODO: EVQ/INDIR Cleanup */
182         ceq_cleanup(&ceq_evq->ev_mbox->ceq);
183         evq_remove_wakeup_ctlr(ceq_evq);
184         put_eventq_raw(ceq_evq);
185 #endif
186 }
187
188 static void ep_put_alarm_evq(struct event_queue *alarm_evq)
189 {
190 #if 0 /* TODO: EVQ/INDIR Cleanup */
191         evq_remove_wakeup_ctlr(alarm_evq);
192         put_eventq(alarm_evq);
193 #endif
194 }
195
196 static void epoll_close(struct user_fd *ufd)
197 {
198         struct epoll_ctlr *ep = container_of(ufd, struct epoll_ctlr, ufd);
199         struct fd_tap_req *tap_reqs, *tap_req_i;
200         struct ceq_event *ceq_ev_i;
201         struct ep_fd_data *ep_fd_i;
202         int nr_tap_req = 0;
203         int nr_done = 0;
204         unsigned int max_ceq_events = ep_get_ceq_max_ever(ep);
205
206         tap_reqs = malloc(sizeof(struct fd_tap_req) * max_ceq_events);
207         memset(tap_reqs, 0, sizeof(struct fd_tap_req) * max_ceq_events);
208         /* Slightly painful, O(n) with no escape hatch */
209         for (int i = 0; i < max_ceq_events; i++) {
210                 ceq_ev_i = ep_get_ceq_ev(ep, i);
211                 /* CEQ should have been big enough for our size */
212                 assert(ceq_ev_i);
213                 ep_fd_i = (struct ep_fd_data*)ceq_ev_i->user_data;
214                 if (!ep_fd_i)
215                         continue;
216                 tap_req_i = &tap_reqs[nr_tap_req++];
217                 tap_req_i->fd = i;
218                 tap_req_i->cmd = FDTAP_CMD_REM;
219                 free(ep_fd_i);
220         }
221         /* Requests could fail if the tapped files are already closed.  We need
222          * to skip the failed one (the +1) and untap the rest. */
223         do {
224                 nr_done += sys_tap_fds(tap_reqs + nr_done,
225                                        nr_tap_req - nr_done);
226                 nr_done += 1;   /* nr_done could be more than nr_tap_req now */
227         } while (nr_done < nr_tap_req);
228         free(tap_reqs);
229         ep_put_ceq_evq(ep->ceq_evq);
230         uth_mutex_lock(ctlrs_mtx);
231         TAILQ_REMOVE(&all_ctlrs, ep, link);
232         uth_mutex_unlock(ctlrs_mtx);
233         uth_mutex_free(ep->mtx);
234         free(ep);
235 }
236
237 static int init_ep_ctlr(struct epoll_ctlr *ep, int size)
238 {
239         if (size == 1)
240                 size = 128;
241         ep->mtx = uth_mutex_alloc();
242         ep->ufd.magic = EPOLL_UFD_MAGIC;
243         ep->ufd.close = epoll_close;
244         /* Size is a hint for the CEQ concurrency.  We can actually handle as
245          * many kernel FDs as is possible. */
246         ep->ceq_evq = ep_get_ceq_evq(ROUNDUPPWR2(size));
247         return 0;
248 }
249
250 static void epoll_fd_closed(int fd)
251 {
252         struct epoll_ctlr *ep;
253
254         /* Lockless peek, avoid locking for every close() */
255         if (TAILQ_EMPTY(&all_ctlrs))
256                 return;
257         uth_mutex_lock(ctlrs_mtx);
258         TAILQ_FOREACH(ep, &all_ctlrs, link)
259                 epoll_ctl(ep->ufd.fd, EPOLL_CTL_DEL, fd, 0);
260         uth_mutex_unlock(ctlrs_mtx);
261 }
262
263 static int ep_alarm_ctor(void *obj, void *priv, int flags)
264 {
265         struct ep_alarm *ep_a = (struct ep_alarm*)obj;
266
267         ep_a->alarm_evq = ep_get_alarm_evq();
268         return 0;
269 }
270
271 static void ep_alarm_dtor(void *obj, void *priv)
272 {
273         struct ep_alarm *ep_a = (struct ep_alarm*)obj;
274
275         /* TODO: (RCU/SLAB).  Somehow the slab allocator is trying to reap our
276          * objects.  Note that when we update userspace to use magazines, the
277          * dtor will fire earlier (when the object is given to the slab layer).
278          * We'll need to be careful about the final freeing of the ev_q. */
279         panic("Epoll alarms should never be destroyed!");
280         ep_put_alarm_evq(ep_a->alarm_evq);
281 }
282
283 static void epoll_init(void *arg)
284 {
285         static struct close_cb epoll_close_cb = {.func = epoll_fd_closed};
286
287         register_close_cb(&epoll_close_cb);
288         ctlrs_mtx = uth_mutex_alloc();
289         ep_alarms_cache = kmem_cache_create("epoll alarms",
290                                 sizeof(struct ep_alarm),
291                                 __alignof__(sizeof(struct ep_alarm)), 0,
292                                 ep_alarm_ctor, ep_alarm_dtor, NULL);
293         assert(ep_alarms_cache);
294 }
295
296 int epoll_create(int size)
297 {
298         int fd;
299         struct epoll_ctlr *ep;
300         static parlib_once_t once = PARLIB_ONCE_INIT;
301
302         parlib_run_once(&once, epoll_init, NULL);
303         /* good thing the arg is a signed int... */
304         if (size < 0) {
305                 errno = EINVAL;
306                 return -1;
307         }
308         ep = malloc(sizeof(struct epoll_ctlr));
309         memset(ep, 0, sizeof(struct epoll_ctlr));
310         if (init_ep_ctlr(ep, size)) {
311                 free(ep);
312                 return -1;
313         }
314         fd = ufd_get_fd(&ep->ufd);
315         if (fd < 0)
316                 free(ep);
317         uth_mutex_lock(ctlrs_mtx);
318         TAILQ_INSERT_TAIL(&all_ctlrs, ep, link);
319         uth_mutex_unlock(ctlrs_mtx);
320         return fd;
321 }
322
323 int epoll_create1(int flags)
324 {
325         /* TODO: we're supposed to support CLOEXEC.  Our FD is a user_fd, so
326          * that'd require some support in glibc's exec to close our epoll ctlr.
327          * */
328         return epoll_create(1);
329 }
330
331 /* Linux's epoll will check for events, even if edge-triggered, during
332  * additions (and probably modifications) to the epoll set.  It's a questionable
333  * policy, since it can hide user bugs.
334  *
335  * We can do the same, though only for EPOLLIN and EPOLLOUT for FDs that can
336  * report their status via stat.  (same as select()).
337  *
338  * Note that this could result in spurious events, which should be fine. */
339 static void fire_existing_events(int fd, int ep_events,
340                                  struct event_queue *ev_q)
341 {
342         struct stat stat_buf[1];
343         struct event_msg ev_msg[1];
344         int ret;
345         int synth_ep_events = 0;
346
347         ret = fstat(fd, stat_buf);
348         assert(!ret);
349         if ((ep_events & EPOLLIN) && S_READABLE(stat_buf->st_mode))
350                 synth_ep_events |= EPOLLIN;
351         if ((ep_events & EPOLLOUT) && S_WRITABLE(stat_buf->st_mode))
352                 synth_ep_events |= EPOLLOUT;
353         if (synth_ep_events) {
354                 ev_msg->ev_type = fd;
355                 ev_msg->ev_arg2 = ep_events_to_taps(synth_ep_events);
356                 ev_msg->ev_arg3 = 0; /* tap->data is unused for epoll. */
357                 sys_send_event(ev_q, ev_msg, vcore_id());
358         }
359 }
360
361 static int __epoll_ctl_add_raw(struct epoll_ctlr *ep, int fd,
362                                struct epoll_event *event)
363 {
364         struct ceq_event *ceq_ev;
365         struct ep_fd_data *ep_fd;
366         struct fd_tap_req tap_req = {0};
367         int ret, filter;
368
369         ceq_ev = ep_get_ceq_ev(ep, fd);
370         if (!ceq_ev) {
371                 errno = ENOMEM;
372                 werrstr("Epoll set cannot grow yet!");
373                 return -1;
374         }
375         ep_fd = (struct ep_fd_data*)ceq_ev->user_data;
376         if (ep_fd) {
377                 errno = EEXIST;
378                 return -1;
379         }
380         tap_req.fd = fd;
381         tap_req.cmd = FDTAP_CMD_ADD;
382         /* EPOLLHUP is implicitly set for all epolls. */
383         filter = ep_events_to_taps(event->events | EPOLLHUP);
384         tap_req.filter = filter;
385         tap_req.ev_q = ep->ceq_evq;
386         tap_req.ev_id = fd;     /* using FD as the CEQ ID */
387         ret = sys_tap_fds(&tap_req, 1);
388         if (ret != 1)
389                 return -1;
390         ep_fd = malloc(sizeof(struct ep_fd_data));
391         ep_fd->fd = fd;
392         ep_fd->filter = filter;
393         ep_fd->ep_event = *event;
394         ep_fd->ep_event.events |= EPOLLHUP;
395         ceq_ev->user_data = (uint64_t)ep_fd;
396         fire_existing_events(fd, ep_fd->ep_event.events, ep->ceq_evq);
397         return 0;
398 }
399
400 static int __epoll_ctl_add(struct epoll_ctlr *ep, int fd,
401                            struct epoll_event *event)
402 {
403         struct fd_tap_req tap_req = {0};
404         int ret, sock_listen_fd, sock_ctl_fd;
405         struct epoll_event listen_event;
406
407         /* Only support ET.  Also, we just ignore EPOLLONESHOT.  That might
408          * work, logically, just with spurious events firing. */
409         if (!(event->events & EPOLLET)) {
410                 errno = EPERM;
411                 werrstr("Epoll level-triggered not supported");
412                 return -1;
413         }
414         if (event->events & EPOLLONESHOT) {
415                 errno = EPERM;
416                 werrstr("Epoll one-shot not supported");
417                 return -1;
418         }
419         /* The sockets-to-plan9 networking shims are a bit inconvenient.  The
420          * user asked us to epoll on an FD, but that FD is actually a Qdata FD.
421          * We might need to actually epoll on the listen_fd.  Further, we don't
422          * know yet whether or not they want the listen FD.  They could epoll on
423          * the socket, then listen later and want to wake up on the listen.
424          *
425          * So in the case we have a socket FD, we'll actually open the listen FD
426          * regardless (glibc handles this), and we'll epoll on both FDs.
427          * Technically, either FD could fire and they'd get an epoll event for
428          * it, but I think socket users will use only listen or data.
429          *
430          * As far as tracking the FD goes for epoll_wait() reporting, if the app
431          * wants to track the FD they think we are using, then they already
432          * passed that in event->data. */
433         _sock_lookup_rock_fds(fd, TRUE, &sock_listen_fd, &sock_ctl_fd);
434         if (sock_listen_fd >= 0) {
435                 listen_event.events = EPOLLET | EPOLLIN | EPOLLHUP;
436                 listen_event.data = event->data;
437                 ret = __epoll_ctl_add_raw(ep, sock_listen_fd, &listen_event);
438                 if (ret < 0)
439                         return ret;
440         }
441         return __epoll_ctl_add_raw(ep, fd, event);
442 }
443
444 static int __epoll_ctl_del_raw(struct epoll_ctlr *ep, int fd,
445                                struct epoll_event *event)
446 {
447         struct ceq_event *ceq_ev;
448         struct ep_fd_data *ep_fd;
449         struct fd_tap_req tap_req = {0};
450
451         ceq_ev = ep_get_ceq_ev(ep, fd);
452         if (!ceq_ev) {
453                 errno = ENOENT;
454                 return -1;
455         }
456         ep_fd = (struct ep_fd_data*)ceq_ev->user_data;
457         if (!ep_fd) {
458                 errno = ENOENT;
459                 return -1;
460         }
461         assert(ep_fd->fd == fd);
462         tap_req.fd = fd;
463         tap_req.cmd = FDTAP_CMD_REM;
464         /* ignoring the return value; we could have failed to remove it if the
465          * FD has already closed and the kernel removed the tap. */
466         sys_tap_fds(&tap_req, 1);
467         ceq_ev->user_data = 0;
468         free(ep_fd);
469         return 0;
470 }
471
472 static int __epoll_ctl_del(struct epoll_ctlr *ep, int fd,
473                            struct epoll_event *event)
474 {
475         int sock_listen_fd, sock_ctl_fd;
476
477         /* If we were dealing with a socket shim FD, we tapped both the listen
478          * and the data file and need to untap both of them.
479          *
480          * We could be called from a close_cb, and we already closed the listen
481          * FD.  In that case, we don't want to try and open it.  If the listen
482          * FD isn't open, then we know it isn't in an epoll set.  We also know
483          * the data FD isn't epolled either, since we always epoll both FDs for
484          * rocks. */
485         _sock_lookup_rock_fds(fd, FALSE, &sock_listen_fd, &sock_ctl_fd);
486         if (sock_listen_fd >= 0) {
487                 /* It's possible to fail here.  Even though we tapped it
488                  * already, if the deletion was triggered from close callbacks,
489                  * it's possible for the sock_listen_fd to be closed first,
490                  * which would have triggered an epoll_ctl_del.  When we get
491                  * around to closing the Rock FD, the listen FD was already
492                  * closed. */
493                 __epoll_ctl_del_raw(ep, sock_listen_fd, event);
494         }
495         return __epoll_ctl_del_raw(ep, fd, event);
496 }
497
498 int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
499 {
500         int ret;
501         struct epoll_ctlr *ep = fd_to_cltr(epfd);
502         if (!ep) {
503                 errno = EBADF;/* or EINVAL */
504                 return -1;
505         }
506         if (fd >= USER_FD_BASE) {
507                 errno = EINVAL;
508                 werrstr("Epoll can't track User FDs");
509                 return -1;
510         }
511         uth_mutex_lock(ep->mtx);
512         switch (op) {
513         case (EPOLL_CTL_MOD):
514                 /* In lieu of a proper MOD, just remove and readd.  The errors
515                  * might not work out well, and there could be a missed event in
516                  * the middle.  Not sure what the guarantees are, but we can
517                  * fake a poke. (TODO). */
518                 ret = __epoll_ctl_del(ep, fd, 0);
519                 if (ret)
520                         break;
521                 ret = __epoll_ctl_add(ep, fd, event);
522                 break;
523         case (EPOLL_CTL_ADD):
524                 ret = __epoll_ctl_add(ep, fd, event);
525                 break;
526         case (EPOLL_CTL_DEL):
527                 ret = __epoll_ctl_del(ep, fd, event);
528                 break;
529         default:
530                 errno = EINVAL;
531                 ret = -1;
532         }
533         uth_mutex_unlock(ep->mtx);
534         return ret;
535 }
536
537 static bool get_ep_event_from_msg(struct epoll_ctlr *ep, struct event_msg *msg,
538                                   struct epoll_event *ep_ev)
539 {
540         struct ceq_event *ceq_ev;
541         struct ep_fd_data *ep_fd;
542
543         ceq_ev = ep_get_ceq_ev(ep, msg->ev_type);
544         /* should never get a tap FD > size of the epoll set */
545         assert(ceq_ev);
546         ep_fd = (struct ep_fd_data*)ceq_ev->user_data;
547         if (!ep_fd) {
548                 /* it's possible the FD was unregistered and this was an old
549                  * event sent to this epoll set. */
550                 return FALSE;
551         }
552         ep_ev->data = ep_fd->ep_event.data;
553         /* The events field was initialized to 0 in epoll_wait() */
554         ep_ev->events |= taps_to_ep_events(msg->ev_arg2);
555         return TRUE;
556 }
557
558 /* Helper: extracts as many epoll_events as possible from the ep. */
559 static int __epoll_wait_poll(struct epoll_ctlr *ep, struct epoll_event *events,
560                              int maxevents)
561 {
562         struct event_msg msg = {0};
563         int nr_ret = 0;
564
565         if (maxevents <= 0)
566                 return 0;
567         /* Locking to protect get_ep_event_from_msg, specifically that the ep_fd
568          * stored at ceq_ev->user_data does not get concurrently removed and
569          * freed. */
570         uth_mutex_lock(ep->mtx);
571         for (int i = 0; i < maxevents; i++) {
572 retry:
573                 if (!uth_check_evqs(&msg, NULL, 1, ep->ceq_evq))
574                         break;
575                 if (!get_ep_event_from_msg(ep, &msg, &events[i]))
576                         goto retry;
577                 nr_ret++;
578         }
579         uth_mutex_unlock(ep->mtx);
580         return nr_ret;
581 }
582
583 /* We should be able to have multiple waiters.  ep shouldn't be closed or
584  * anything, since we have the FD (that'd be bad programming on the user's
585  * behalf).  We could have concurrent ADD/MOD/DEL operations (which lock). */
586 static int __epoll_wait(struct epoll_ctlr *ep, struct epoll_event *events,
587                         int maxevents, int timeout)
588 {
589         struct event_msg msg = {0};
590         struct event_msg dummy_msg;
591         struct event_queue *which_evq;
592         struct ep_alarm *ep_a;
593         int nr_ret;
594
595         nr_ret = __epoll_wait_poll(ep, events, maxevents);
596         if (nr_ret)
597                 return nr_ret;
598         if (timeout == 0)
599                 return 0;
600         /* From here on down, we're going to block until there is some activity
601          */
602         if (timeout != -1) {
603                 ep_a = kmem_cache_alloc(ep_alarms_cache, 0);
604                 assert(ep_a);
605                 syscall_async_evq(&ep_a->sysc, ep_a->alarm_evq, SYS_block,
606                                   timeout * 1000);
607                 uth_blockon_evqs(&msg, &which_evq, 2, ep->ceq_evq,
608                                  ep_a->alarm_evq);
609                 if (which_evq == ep_a->alarm_evq) {
610                         kmem_cache_free(ep_alarms_cache, ep_a);
611                         return 0;
612                 }
613                 /* The alarm sysc may or may not have finished yet.  This will
614                  * force it to *start* to finish iff it is still a submitted
615                  * syscall. */
616                 sys_abort_sysc(&ep_a->sysc);
617                 /* But we still need to wait until the syscall completed.  Need
618                  * a dummy msg, since we don't want to clobber the real msg. */
619                 uth_blockon_evqs(&dummy_msg, 0, 1, ep_a->alarm_evq);
620                 kmem_cache_free(ep_alarms_cache, ep_a);
621         } else {
622                 uth_blockon_evqs(&msg, &which_evq, 1, ep->ceq_evq);
623         }
624         uth_mutex_lock(ep->mtx);
625         if (get_ep_event_from_msg(ep, &msg, &events[0]))
626                 nr_ret = 1;
627         uth_mutex_unlock(ep->mtx);
628         /* We had to extract one message already as part of the blocking
629          * process.  We might be able to get more. */
630         nr_ret += __epoll_wait_poll(ep, events + nr_ret, maxevents - nr_ret);
631         /* This is a little nasty and hopefully a rare race.  We still might not
632          * have a ret, but we expected to block until we had something.  We
633          * didn't time out yet, but we spuriously woke up.  We need to try again
634          * (ideally, we'd subtract the time left from the original timeout). */
635         if (!nr_ret)
636                 return __epoll_wait(ep, events, maxevents, timeout);
637         return nr_ret;
638 }
639
640 int epoll_wait(int epfd, struct epoll_event *events, int maxevents,
641                int timeout)
642 {
643         struct epoll_ctlr *ep = fd_to_cltr(epfd);
644
645         if (!ep) {
646                 errno = EBADF;/* or EINVAL */
647                 return -1;
648         }
649         if (maxevents <= 0) {
650                 errno = EINVAL;
651                 return -1;
652         }
653         for (int i = 0; i < maxevents; i++)
654                 events[i].events = 0;
655         return __epoll_wait(ep, events, maxevents, timeout);
656 }
657
658 int epoll_pwait(int epfd, struct epoll_event *events, int maxevents,
659                 int timeout, const sigset_t *sigmask)
660 {
661         int ready;
662         sigset_t origmask;
663
664         /* TODO: this is probably racy */
665         sigprocmask(SIG_SETMASK, sigmask, &origmask);
666         ready = epoll_wait(epfd, events, maxevents, timeout);
667         sigprocmask(SIG_SETMASK, &origmask, NULL);
668         return ready;
669 }