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