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