vmm: Use a task_thread cache
[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);
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         sock_listen_fd = _sock_lookup_listen_fd(fd);
439         if (sock_listen_fd >= 0) {
440                 /* It's possible to fail here.  Even though we tapped it already, if the
441                  * deletion was triggered from close callbacks, it's possible for the
442                  * sock_listen_fd to be closed first, which would have triggered an
443                  * epoll_ctl_del.  When we get around to closing the Rock FD, the listen
444                  * FD was already closed. */
445                 __epoll_ctl_del(ep, sock_listen_fd, event);
446         }
447         ceq_ev = ep_get_ceq_ev(ep, fd);
448         if (!ceq_ev) {
449                 errno = ENOENT;
450                 return -1;
451         }
452         ep_fd = (struct ep_fd_data*)ceq_ev->user_data;
453         if (!ep_fd) {
454                 errno = ENOENT;
455                 return -1;
456         }
457         assert(ep_fd->fd == fd);
458         tap_req.fd = fd;
459         tap_req.cmd = FDTAP_CMD_REM;
460         /* ignoring the return value; we could have failed to remove it if the FD
461          * has already closed and the kernel removed the tap. */
462         sys_tap_fds(&tap_req, 1);
463         ceq_ev->user_data = 0;
464         free(ep_fd);
465         return 0;
466 }
467
468 int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
469 {
470         int ret;
471         struct epoll_ctlr *ep = fd_to_cltr(epfd);
472         if (!ep) {
473                 errno = EBADF;/* or EINVAL */
474                 return -1;
475         }
476         if (fd >= USER_FD_BASE) {
477                 errno = EINVAL;
478                 werrstr("Epoll can't track User FDs");
479                 return -1;
480         }
481         uth_mutex_lock(ep->mtx);
482         switch (op) {
483                 case (EPOLL_CTL_MOD):
484                         /* In lieu of a proper MOD, just remove and readd.  The errors might
485                          * not work out well, and there could be a missed event in the
486                          * middle.  Not sure what the guarantees are, but we can fake a
487                          * poke. (TODO). */
488                         ret = __epoll_ctl_del(ep, fd, 0);
489                         if (ret)
490                                 break;
491                         ret = __epoll_ctl_add(ep, fd, event);
492                         break;
493                 case (EPOLL_CTL_ADD):
494                         ret = __epoll_ctl_add(ep, fd, event);
495                         break;
496                 case (EPOLL_CTL_DEL):
497                         ret = __epoll_ctl_del(ep, fd, event);
498                         break;
499                 default:
500                         errno = EINVAL;
501                         ret = -1;
502         }
503         uth_mutex_unlock(ep->mtx);
504         return ret;
505 }
506
507 static bool get_ep_event_from_msg(struct epoll_ctlr *ep, struct event_msg *msg,
508                                   struct epoll_event *ep_ev)
509 {
510         struct ceq_event *ceq_ev;
511         struct ep_fd_data *ep_fd;
512
513         ceq_ev = ep_get_ceq_ev(ep, msg->ev_type);
514         /* should never get a tap FD > size of the epoll set */
515         assert(ceq_ev);
516         ep_fd = (struct ep_fd_data*)ceq_ev->user_data;
517         if (!ep_fd) {
518                 /* it's possible the FD was unregistered and this was an old
519                  * event sent to this epoll set. */
520                 return FALSE;
521         }
522         ep_ev->data = ep_fd->ep_event.data;
523         /* The events field was initialized to 0 in epoll_wait() */
524         ep_ev->events |= taps_to_ep_events(msg->ev_arg2);
525         return TRUE;
526 }
527
528 /* Helper: extracts as many epoll_events as possible from the ep. */
529 static int __epoll_wait_poll(struct epoll_ctlr *ep, struct epoll_event *events,
530                              int maxevents)
531 {
532         struct event_msg msg = {0};
533         int nr_ret = 0;
534
535         if (maxevents <= 0)
536                 return 0;
537         /* Locking to protect get_ep_event_from_msg, specifically that the ep_fd
538          * stored at ceq_ev->user_data does not get concurrently removed and
539          * freed. */
540         uth_mutex_lock(ep->mtx);
541         for (int i = 0; i < maxevents; i++) {
542 retry:
543                 if (!uth_check_evqs(&msg, NULL, 1, ep->ceq_evq))
544                         break;
545                 if (!get_ep_event_from_msg(ep, &msg, &events[i]))
546                         goto retry;
547                 nr_ret++;
548         }
549         uth_mutex_unlock(ep->mtx);
550         return nr_ret;
551 }
552
553 /* We should be able to have multiple waiters.  ep shouldn't be closed or
554  * anything, since we have the FD (that'd be bad programming on the user's
555  * behalf).  We could have concurrent ADD/MOD/DEL operations (which lock). */
556 static int __epoll_wait(struct epoll_ctlr *ep, struct epoll_event *events,
557                         int maxevents, int timeout)
558 {
559         struct event_msg msg = {0};
560         struct event_msg dummy_msg;
561         struct event_queue *which_evq;
562         struct ep_alarm *ep_a;
563         int nr_ret;
564
565         nr_ret = __epoll_wait_poll(ep, events, maxevents);
566         if (nr_ret)
567                 return nr_ret;
568         if (timeout == 0)
569                 return 0;
570         /* From here on down, we're going to block until there is some activity */
571         if (timeout != -1) {
572                 ep_a = kmem_cache_alloc(ep_alarms_cache, 0);
573                 assert(ep_a);
574                 syscall_async_evq(&ep_a->sysc, ep_a->alarm_evq, SYS_block,
575                                   timeout * 1000);
576                 uth_blockon_evqs(&msg, &which_evq, 2, ep->ceq_evq, ep_a->alarm_evq);
577                 if (which_evq == ep_a->alarm_evq) {
578                         kmem_cache_free(ep_alarms_cache, ep_a);
579                         return 0;
580                 }
581                 /* The alarm sysc may or may not have finished yet.  This will force it
582                  * to *start* to finish iff it is still a submitted syscall. */
583                 sys_abort_sysc(&ep_a->sysc);
584                 /* But we still need to wait until the syscall completed.  Need a
585                  * dummy msg, since we don't want to clobber the real msg. */
586                 uth_blockon_evqs(&dummy_msg, 0, 1, ep_a->alarm_evq);
587                 kmem_cache_free(ep_alarms_cache, ep_a);
588         } else {
589                 uth_blockon_evqs(&msg, &which_evq, 1, ep->ceq_evq);
590         }
591         uth_mutex_lock(ep->mtx);
592         if (get_ep_event_from_msg(ep, &msg, &events[0]))
593                 nr_ret = 1;
594         uth_mutex_unlock(ep->mtx);
595         /* We had to extract one message already as part of the blocking process.
596          * We might be able to get more. */
597         nr_ret += __epoll_wait_poll(ep, events + nr_ret, maxevents - nr_ret);
598         /* This is a little nasty and hopefully a rare race.  We still might not
599          * have a ret, but we expected to block until we had something.  We didn't
600          * time out yet, but we spuriously woke up.  We need to try again (ideally,
601          * we'd subtract the time left from the original timeout). */
602         if (!nr_ret)
603                 return __epoll_wait(ep, events, maxevents, timeout);
604         return nr_ret;
605 }
606
607 int epoll_wait(int epfd, struct epoll_event *events, int maxevents,
608                int timeout)
609 {
610         struct epoll_ctlr *ep = fd_to_cltr(epfd);
611
612         if (!ep) {
613                 errno = EBADF;/* or EINVAL */
614                 return -1;
615         }
616         if (maxevents <= 0) {
617                 errno = EINVAL;
618                 return -1;
619         }
620         for (int i = 0; i < maxevents; i++)
621                 events[i].events = 0;
622         return __epoll_wait(ep, events, maxevents, timeout);
623 }
624
625 int epoll_pwait(int epfd, struct epoll_event *events, int maxevents,
626                 int timeout, const sigset_t *sigmask)
627 {
628         int ready;
629         sigset_t origmask;
630         /* TODO: this is probably racy */
631         sigprocmask(SIG_SETMASK, sigmask, &origmask);
632         ready = epoll_wait(epfd, events, maxevents, timeout);
633         sigprocmask(SIG_SETMASK, &origmask, NULL);
634         return ready;
635 }