talloc: use the system pytalloc-util for python3 as well
[sfrench/samba-autobuild/.git] / lib / tevent / tevent_epoll.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    main select loop and event handling - epoll implementation
5
6    Copyright (C) Andrew Tridgell        2003-2005
7    Copyright (C) Stefan Metzmacher      2005-2013
8    Copyright (C) Jeremy Allison         2013
9
10      ** NOTE! The following LGPL license applies to the tevent
11      ** library. This does NOT imply that all of Samba is released
12      ** under the LGPL
13
14    This library is free software; you can redistribute it and/or
15    modify it under the terms of the GNU Lesser General Public
16    License as published by the Free Software Foundation; either
17    version 3 of the License, or (at your option) any later version.
18
19    This library is distributed in the hope that it will be useful,
20    but WITHOUT ANY WARRANTY; without even the implied warranty of
21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22    Lesser General Public License for more details.
23
24    You should have received a copy of the GNU Lesser General Public
25    License along with this library; if not, see <http://www.gnu.org/licenses/>.
26 */
27
28 #include "replace.h"
29 #include "system/filesys.h"
30 #include "system/select.h"
31 #include "tevent.h"
32 #include "tevent_internal.h"
33 #include "tevent_util.h"
34
35 struct epoll_event_context {
36         /* a pointer back to the generic event_context */
37         struct tevent_context *ev;
38
39         /* when using epoll this is the handle from epoll_create */
40         int epoll_fd;
41
42         pid_t pid;
43
44         bool panic_force_replay;
45         bool *panic_state;
46         bool (*panic_fallback)(struct tevent_context *ev, bool replay);
47 };
48
49 #define EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT      (1<<0)
50 #define EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR   (1<<1)
51 #define EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR      (1<<2)
52 #define EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX        (1<<3)
53
54 #ifdef TEST_PANIC_FALLBACK
55
56 static int epoll_create_panic_fallback(struct epoll_event_context *epoll_ev,
57                                        int size)
58 {
59         if (epoll_ev->panic_fallback == NULL) {
60                 return epoll_create(size);
61         }
62
63         /* 50% of the time, fail... */
64         if ((random() % 2) == 0) {
65                 errno = EINVAL;
66                 return -1;
67         }
68
69         return epoll_create(size);
70 }
71
72 static int epoll_ctl_panic_fallback(struct epoll_event_context *epoll_ev,
73                                     int epfd, int op, int fd,
74                                     struct epoll_event *event)
75 {
76         if (epoll_ev->panic_fallback == NULL) {
77                 return epoll_ctl(epfd, op, fd, event);
78         }
79
80         /* 50% of the time, fail... */
81         if ((random() % 2) == 0) {
82                 errno = EINVAL;
83                 return -1;
84         }
85
86         return epoll_ctl(epfd, op, fd, event);
87 }
88
89 static int epoll_wait_panic_fallback(struct epoll_event_context *epoll_ev,
90                                      int epfd,
91                                      struct epoll_event *events,
92                                      int maxevents,
93                                      int timeout)
94 {
95         if (epoll_ev->panic_fallback == NULL) {
96                 return epoll_wait(epfd, events, maxevents, timeout);
97         }
98
99         /* 50% of the time, fail... */
100         if ((random() % 2) == 0) {
101                 errno = EINVAL;
102                 return -1;
103         }
104
105         return epoll_wait(epfd, events, maxevents, timeout);
106 }
107
108 #define epoll_create(_size) \
109         epoll_create_panic_fallback(epoll_ev, _size)
110 #define epoll_ctl(_epfd, _op, _fd, _event) \
111         epoll_ctl_panic_fallback(epoll_ev,_epfd, _op, _fd, _event)
112 #define epoll_wait(_epfd, _events, _maxevents, _timeout) \
113         epoll_wait_panic_fallback(epoll_ev, _epfd, _events, _maxevents, _timeout)
114 #endif
115
116 /*
117   called to set the panic fallback function.
118 */
119 _PRIVATE_ void tevent_epoll_set_panic_fallback(struct tevent_context *ev,
120                                 bool (*panic_fallback)(struct tevent_context *ev,
121                                                        bool replay))
122 {
123         struct epoll_event_context *epoll_ev =
124                 talloc_get_type_abort(ev->additional_data,
125                 struct epoll_event_context);
126
127         epoll_ev->panic_fallback = panic_fallback;
128 }
129
130 /*
131   called when a epoll call fails
132 */
133 static void epoll_panic(struct epoll_event_context *epoll_ev,
134                         const char *reason, bool replay)
135 {
136         struct tevent_context *ev = epoll_ev->ev;
137         bool (*panic_fallback)(struct tevent_context *ev, bool replay);
138
139         panic_fallback = epoll_ev->panic_fallback;
140
141         if (epoll_ev->panic_state != NULL) {
142                 *epoll_ev->panic_state = true;
143         }
144
145         if (epoll_ev->panic_force_replay) {
146                 replay = true;
147         }
148
149         TALLOC_FREE(ev->additional_data);
150
151         if (panic_fallback == NULL) {
152                 tevent_debug(ev, TEVENT_DEBUG_FATAL,
153                         "%s (%s) replay[%u] - calling abort()\n",
154                         reason, strerror(errno), (unsigned)replay);
155                 abort();
156         }
157
158         tevent_debug(ev, TEVENT_DEBUG_ERROR,
159                      "%s (%s) replay[%u] - calling panic_fallback\n",
160                      reason, strerror(errno), (unsigned)replay);
161
162         if (!panic_fallback(ev, replay)) {
163                 /* Fallback failed. */
164                 tevent_debug(ev, TEVENT_DEBUG_FATAL,
165                         "%s (%s) replay[%u] - calling abort()\n",
166                         reason, strerror(errno), (unsigned)replay);
167                 abort();
168         }
169 }
170
171 /*
172   map from TEVENT_FD_* to EPOLLIN/EPOLLOUT
173 */
174 static uint32_t epoll_map_flags(uint16_t flags)
175 {
176         uint32_t ret = 0;
177         if (flags & TEVENT_FD_READ) ret |= (EPOLLIN | EPOLLERR | EPOLLHUP);
178         if (flags & TEVENT_FD_WRITE) ret |= (EPOLLOUT | EPOLLERR | EPOLLHUP);
179         return ret;
180 }
181
182 /*
183  free the epoll fd
184 */
185 static int epoll_ctx_destructor(struct epoll_event_context *epoll_ev)
186 {
187         close(epoll_ev->epoll_fd);
188         epoll_ev->epoll_fd = -1;
189         return 0;
190 }
191
192 /*
193  init the epoll fd
194 */
195 static int epoll_init_ctx(struct epoll_event_context *epoll_ev)
196 {
197         epoll_ev->epoll_fd = epoll_create(64);
198         if (epoll_ev->epoll_fd == -1) {
199                 tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
200                              "Failed to create epoll handle.\n");
201                 return -1;
202         }
203
204         if (!ev_set_close_on_exec(epoll_ev->epoll_fd)) {
205                 tevent_debug(epoll_ev->ev, TEVENT_DEBUG_WARNING,
206                              "Failed to set close-on-exec, file descriptor may be leaked to children.\n");
207         }
208
209         epoll_ev->pid = getpid();
210         talloc_set_destructor(epoll_ev, epoll_ctx_destructor);
211
212         return 0;
213 }
214
215 static void epoll_update_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde);
216
217 /*
218   reopen the epoll handle when our pid changes
219   see http://junkcode.samba.org/ftp/unpacked/junkcode/epoll_fork.c for an
220   demonstration of why this is needed
221  */
222 static void epoll_check_reopen(struct epoll_event_context *epoll_ev)
223 {
224         struct tevent_fd *fde;
225         bool *caller_panic_state = epoll_ev->panic_state;
226         bool panic_triggered = false;
227
228         if (epoll_ev->pid == getpid()) {
229                 return;
230         }
231
232         close(epoll_ev->epoll_fd);
233         epoll_ev->epoll_fd = epoll_create(64);
234         if (epoll_ev->epoll_fd == -1) {
235                 epoll_panic(epoll_ev, "epoll_create() failed", false);
236                 return;
237         }
238
239         if (!ev_set_close_on_exec(epoll_ev->epoll_fd)) {
240                 tevent_debug(epoll_ev->ev, TEVENT_DEBUG_WARNING,
241                              "Failed to set close-on-exec, file descriptor may be leaked to children.\n");
242         }
243
244         epoll_ev->pid = getpid();
245         epoll_ev->panic_state = &panic_triggered;
246         for (fde=epoll_ev->ev->fd_events;fde;fde=fde->next) {
247                 fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
248                 epoll_update_event(epoll_ev, fde);
249
250                 if (panic_triggered) {
251                         if (caller_panic_state != NULL) {
252                                 *caller_panic_state = true;
253                         }
254                         return;
255                 }
256         }
257         epoll_ev->panic_state = NULL;
258 }
259
260 /*
261  epoll cannot add the same file descriptor twice, once
262  with read, once with write which is allowed by the
263  tevent backend. Multiplex the existing fde, flag it
264  as such so we can search for the correct fde on
265  event triggering.
266 */
267
268 static int epoll_add_multiplex_fd(struct epoll_event_context *epoll_ev,
269                                   struct tevent_fd *add_fde)
270 {
271         struct epoll_event event;
272         struct tevent_fd *mpx_fde;
273         int ret;
274
275         /* Find the existing fde that caused the EEXIST error. */
276         for (mpx_fde = epoll_ev->ev->fd_events; mpx_fde; mpx_fde = mpx_fde->next) {
277                 if (mpx_fde->fd != add_fde->fd) {
278                         continue;
279                 }
280
281                 if (mpx_fde == add_fde) {
282                         continue;
283                 }
284
285                 break;
286         }
287         if (mpx_fde == NULL) {
288                 tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
289                              "can't find multiplex fde for fd[%d]",
290                              add_fde->fd);
291                 return -1;
292         }
293
294         if (mpx_fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
295                 /* Logic error. Can't have more than 2 multiplexed fde's. */
296                 tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
297                              "multiplex fde for fd[%d] is already multiplexed\n",
298                              mpx_fde->fd);
299                 return -1;
300         }
301
302         /*
303          * The multiplex fde must have the same fd, and also
304          * already have an epoll event attached.
305          */
306         if (!(mpx_fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT)) {
307                 /* Logic error. Can't have more than 2 multiplexed fde's. */
308                 tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
309                              "multiplex fde for fd[%d] has no event\n",
310                              mpx_fde->fd);
311                 return -1;
312         }
313
314         /* Modify the mpx_fde to add in the new flags. */
315         ZERO_STRUCT(event);
316         event.events = epoll_map_flags(mpx_fde->flags);
317         event.events |= epoll_map_flags(add_fde->flags);
318         event.data.ptr = mpx_fde;
319         ret = epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_MOD, mpx_fde->fd, &event);
320         if (ret != 0 && errno == EBADF) {
321                 tevent_debug(epoll_ev->ev, TEVENT_DEBUG_ERROR,
322                              "EPOLL_CTL_MOD EBADF for "
323                              "add_fde[%p] mpx_fde[%p] fd[%d] - disabling\n",
324                              add_fde, mpx_fde, add_fde->fd);
325                 DLIST_REMOVE(epoll_ev->ev->fd_events, mpx_fde);
326                 mpx_fde->event_ctx = NULL;
327                 DLIST_REMOVE(epoll_ev->ev->fd_events, add_fde);
328                 add_fde->event_ctx = NULL;
329                 return 0;
330         } else if (ret != 0) {
331                 return ret;
332         }
333
334         /*
335          * Make each fde->additional_data pointers point at each other
336          * so we can look them up from each other. They are now paired.
337          */
338         mpx_fde->additional_data = (struct tevent_fd *)add_fde;
339         add_fde->additional_data = (struct tevent_fd *)mpx_fde;
340
341         /* Now flag both fde's as being multiplexed. */
342         mpx_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX;
343         add_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX;
344
345         /* we need to keep the GOT_ERROR flag */
346         if (mpx_fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR) {
347                 add_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR;
348         }
349
350         return 0;
351 }
352
353 /*
354  add the epoll event to the given fd_event
355 */
356 static void epoll_add_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde)
357 {
358         struct epoll_event event;
359         int ret;
360         struct tevent_fd *mpx_fde = NULL;
361
362         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
363         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
364
365         if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
366                 /*
367                  * This is a multiplexed fde, we need to include both
368                  * flags in the modified event.
369                  */
370                 mpx_fde = talloc_get_type_abort(fde->additional_data,
371                                                 struct tevent_fd);
372
373                 mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
374                 mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
375         }
376
377         ZERO_STRUCT(event);
378         event.events = epoll_map_flags(fde->flags);
379         if (mpx_fde != NULL) {
380                 event.events |= epoll_map_flags(mpx_fde->flags);
381         }
382         event.data.ptr = fde;
383         ret = epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_ADD, fde->fd, &event);
384         if (ret != 0 && errno == EBADF) {
385                 tevent_debug(epoll_ev->ev, TEVENT_DEBUG_ERROR,
386                              "EPOLL_CTL_ADD EBADF for "
387                              "fde[%p] mpx_fde[%p] fd[%d] - disabling\n",
388                              fde, mpx_fde, fde->fd);
389                 DLIST_REMOVE(epoll_ev->ev->fd_events, fde);
390                 fde->event_ctx = NULL;
391                 if (mpx_fde != NULL) {
392                         DLIST_REMOVE(epoll_ev->ev->fd_events, mpx_fde);
393                         mpx_fde->event_ctx = NULL;
394                 }
395                 return;
396         } else if (ret != 0 && errno == EEXIST && mpx_fde == NULL) {
397                 ret = epoll_add_multiplex_fd(epoll_ev, fde);
398                 if (ret != 0) {
399                         epoll_panic(epoll_ev, "epoll_add_multiplex_fd failed",
400                                     false);
401                         return;
402                 }
403         } else if (ret != 0) {
404                 epoll_panic(epoll_ev, "EPOLL_CTL_ADD failed", false);
405                 return;
406         }
407
408         fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
409         /* only if we want to read we want to tell the event handler about errors */
410         if (fde->flags & TEVENT_FD_READ) {
411                 fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
412         }
413
414         if (mpx_fde == NULL) {
415                 return;
416         }
417
418         mpx_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
419         /* only if we want to read we want to tell the event handler about errors */
420         if (mpx_fde->flags & TEVENT_FD_READ) {
421                 mpx_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
422         }
423 }
424
425 /*
426  delete the epoll event for given fd_event
427 */
428 static void epoll_del_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde)
429 {
430         struct epoll_event event;
431         int ret;
432         struct tevent_fd *mpx_fde = NULL;
433
434         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
435         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
436
437         if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
438                 /*
439                  * This is a multiplexed fde, we need to modify both events.
440                  */
441                 mpx_fde = talloc_get_type_abort(fde->additional_data,
442                                                 struct tevent_fd);
443
444                 mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
445                 mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
446         }
447
448         ZERO_STRUCT(event);
449         ret = epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_DEL, fde->fd, &event);
450         if (ret != 0 && errno == ENOENT) {
451                 /*
452                  * This can happen after a epoll_check_reopen
453                  * within epoll_event_fd_destructor.
454                  */
455                 tevent_debug(epoll_ev->ev, TEVENT_DEBUG_TRACE,
456                              "EPOLL_CTL_DEL ignoring ENOENT for fd[%d]\n",
457                              fde->fd);
458                 return;
459         } else if (ret != 0 && errno == EBADF) {
460                 tevent_debug(epoll_ev->ev, TEVENT_DEBUG_WARNING,
461                              "EPOLL_CTL_DEL EBADF for "
462                              "fde[%p] mpx_fde[%p] fd[%d] - disabling\n",
463                              fde, mpx_fde, fde->fd);
464                 DLIST_REMOVE(epoll_ev->ev->fd_events, fde);
465                 fde->event_ctx = NULL;
466                 if (mpx_fde != NULL) {
467                         DLIST_REMOVE(epoll_ev->ev->fd_events, mpx_fde);
468                         mpx_fde->event_ctx = NULL;
469                 }
470                 return;
471         } else if (ret != 0) {
472                 epoll_panic(epoll_ev, "EPOLL_CTL_DEL failed", false);
473                 return;
474         }
475 }
476
477 /*
478  change the epoll event to the given fd_event
479 */
480 static void epoll_mod_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde)
481 {
482         struct tevent_fd *mpx_fde = NULL;
483         struct epoll_event event;
484         int ret;
485
486         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
487         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
488
489         if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
490                 /*
491                  * This is a multiplexed fde, we need to include both
492                  * flags in the modified event.
493                  */
494                 mpx_fde = talloc_get_type_abort(fde->additional_data,
495                                                 struct tevent_fd);
496
497                 mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
498                 mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
499         }
500
501         ZERO_STRUCT(event);
502         event.events = epoll_map_flags(fde->flags);
503         if (mpx_fde != NULL) {
504                 event.events |= epoll_map_flags(mpx_fde->flags);
505         }
506         event.data.ptr = fde;
507         ret = epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_MOD, fde->fd, &event);
508         if (ret != 0 && errno == EBADF) {
509                 tevent_debug(epoll_ev->ev, TEVENT_DEBUG_ERROR,
510                              "EPOLL_CTL_MOD EBADF for "
511                              "fde[%p] mpx_fde[%p] fd[%d] - disabling\n",
512                              fde, mpx_fde, fde->fd);
513                 DLIST_REMOVE(epoll_ev->ev->fd_events, fde);
514                 fde->event_ctx = NULL;
515                 if (mpx_fde != NULL) {
516                         DLIST_REMOVE(epoll_ev->ev->fd_events, mpx_fde);
517                         mpx_fde->event_ctx = NULL;
518                 }
519                 return;
520         } else if (ret != 0) {
521                 epoll_panic(epoll_ev, "EPOLL_CTL_MOD failed", false);
522                 return;
523         }
524
525         fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
526         /* only if we want to read we want to tell the event handler about errors */
527         if (fde->flags & TEVENT_FD_READ) {
528                 fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
529         }
530
531         if (mpx_fde == NULL) {
532                 return;
533         }
534
535         mpx_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
536         /* only if we want to read we want to tell the event handler about errors */
537         if (mpx_fde->flags & TEVENT_FD_READ) {
538                 mpx_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
539         }
540 }
541
542 static void epoll_update_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde)
543 {
544         bool got_error = (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR);
545         bool want_read = (fde->flags & TEVENT_FD_READ);
546         bool want_write= (fde->flags & TEVENT_FD_WRITE);
547         struct tevent_fd *mpx_fde = NULL;
548
549         if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
550                 /*
551                  * work out what the multiplexed fde wants.
552                  */
553                 mpx_fde = talloc_get_type_abort(fde->additional_data,
554                                                 struct tevent_fd);
555
556                 if (mpx_fde->flags & TEVENT_FD_READ) {
557                         want_read = true;
558                 }
559
560                 if (mpx_fde->flags & TEVENT_FD_WRITE) {
561                         want_write = true;
562                 }
563         }
564
565         /* there's already an event */
566         if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT) {
567                 if (want_read || (want_write && !got_error)) {
568                         epoll_mod_event(epoll_ev, fde);
569                         return;
570                 }
571                 /* 
572                  * if we want to match the select behavior, we need to remove the epoll_event
573                  * when the caller isn't interested in events.
574                  *
575                  * this is because epoll reports EPOLLERR and EPOLLHUP, even without asking for them
576                  */
577                 epoll_del_event(epoll_ev, fde);
578                 return;
579         }
580
581         /* there's no epoll_event attached to the fde */
582         if (want_read || (want_write && !got_error)) {
583                 epoll_add_event(epoll_ev, fde);
584                 return;
585         }
586 }
587
588 /*
589   Cope with epoll returning EPOLLHUP|EPOLLERR on an event.
590   Return true if there's nothing else to do, false if
591   this event needs further handling.
592 */
593 static bool epoll_handle_hup_or_err(struct epoll_event_context *epoll_ev,
594                                 struct tevent_fd *fde)
595 {
596         if (fde == NULL) {
597                 /* Nothing to do if no event. */
598                 return true;
599         }
600
601         fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR;
602         /*
603          * if we only wait for TEVENT_FD_WRITE, we should not tell the
604          * event handler about it, and remove the epoll_event,
605          * as we only report errors when waiting for read events,
606          * to match the select() behavior
607          */
608         if (!(fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR)) {
609                 /*
610                  * Do the same as the poll backend and
611                  * remove the writeable flag.
612                  */
613                 fde->flags &= ~TEVENT_FD_WRITE;
614                 return true;
615         }
616         /* This has TEVENT_FD_READ set, we're not finished. */
617         return false;
618 }
619
620 /*
621   event loop handling using epoll
622 */
623 static int epoll_event_loop(struct epoll_event_context *epoll_ev, struct timeval *tvalp)
624 {
625         int ret, i;
626 #define MAXEVENTS 1
627         struct epoll_event events[MAXEVENTS];
628         int timeout = -1;
629         int wait_errno;
630
631         if (tvalp) {
632                 /* it's better to trigger timed events a bit later than too early */
633                 timeout = ((tvalp->tv_usec+999) / 1000) + (tvalp->tv_sec*1000);
634         }
635
636         if (epoll_ev->ev->signal_events &&
637             tevent_common_check_signal(epoll_ev->ev)) {
638                 return 0;
639         }
640
641         tevent_trace_point_callback(epoll_ev->ev, TEVENT_TRACE_BEFORE_WAIT);
642         ret = epoll_wait(epoll_ev->epoll_fd, events, MAXEVENTS, timeout);
643         wait_errno = errno;
644         tevent_trace_point_callback(epoll_ev->ev, TEVENT_TRACE_AFTER_WAIT);
645
646         if (ret == -1 && wait_errno == EINTR && epoll_ev->ev->signal_events) {
647                 if (tevent_common_check_signal(epoll_ev->ev)) {
648                         return 0;
649                 }
650         }
651
652         if (ret == -1 && wait_errno != EINTR) {
653                 epoll_panic(epoll_ev, "epoll_wait() failed", true);
654                 return -1;
655         }
656
657         if (ret == 0 && tvalp) {
658                 /* we don't care about a possible delay here */
659                 tevent_common_loop_timer_delay(epoll_ev->ev);
660                 return 0;
661         }
662
663         for (i=0;i<ret;i++) {
664                 struct tevent_fd *fde = talloc_get_type(events[i].data.ptr,
665                                                        struct tevent_fd);
666                 uint16_t flags = 0;
667                 struct tevent_fd *mpx_fde = NULL;
668
669                 if (fde == NULL) {
670                         epoll_panic(epoll_ev, "epoll_wait() gave bad data", true);
671                         return -1;
672                 }
673                 if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
674                         /*
675                          * Save off the multiplexed event in case we need
676                          * to use it to call the handler function.
677                          */
678                         mpx_fde = talloc_get_type_abort(fde->additional_data,
679                                                         struct tevent_fd);
680                 }
681                 if (events[i].events & (EPOLLHUP|EPOLLERR)) {
682                         bool handled_fde = epoll_handle_hup_or_err(epoll_ev, fde);
683                         bool handled_mpx = epoll_handle_hup_or_err(epoll_ev, mpx_fde);
684
685                         if (handled_fde && handled_mpx) {
686                                 epoll_update_event(epoll_ev, fde);
687                                 continue;
688                         }
689
690                         if (!handled_mpx) {
691                                 /*
692                                  * If the mpx event was the one that needs
693                                  * further handling, it's the TEVENT_FD_READ
694                                  * event so switch over and call that handler.
695                                  */
696                                 fde = mpx_fde;
697                                 mpx_fde = NULL;
698                         }
699                         flags |= TEVENT_FD_READ;
700                 }
701                 if (events[i].events & EPOLLIN) flags |= TEVENT_FD_READ;
702                 if (events[i].events & EPOLLOUT) flags |= TEVENT_FD_WRITE;
703
704                 if (flags & TEVENT_FD_WRITE) {
705                         if (fde->flags & TEVENT_FD_WRITE) {
706                                 mpx_fde = NULL;
707                         }
708                         if (mpx_fde && mpx_fde->flags & TEVENT_FD_WRITE) {
709                                 fde = mpx_fde;
710                                 mpx_fde = NULL;
711                         }
712                 }
713
714                 if (mpx_fde) {
715                         /* Ensure we got the right fde. */
716                         if ((flags & fde->flags) == 0) {
717                                 fde = mpx_fde;
718                                 mpx_fde = NULL;
719                         }
720                 }
721
722                 /*
723                  * make sure we only pass the flags
724                  * the handler is expecting.
725                  */
726                 flags &= fde->flags;
727                 if (flags) {
728                         fde->handler(epoll_ev->ev, fde, flags, fde->private_data);
729                         break;
730                 }
731         }
732
733         return 0;
734 }
735
736 /*
737   create a epoll_event_context structure.
738 */
739 static int epoll_event_context_init(struct tevent_context *ev)
740 {
741         int ret;
742         struct epoll_event_context *epoll_ev;
743
744         /*
745          * We might be called during tevent_re_initialise()
746          * which means we need to free our old additional_data.
747          */
748         TALLOC_FREE(ev->additional_data);
749
750         epoll_ev = talloc_zero(ev, struct epoll_event_context);
751         if (!epoll_ev) return -1;
752         epoll_ev->ev = ev;
753         epoll_ev->epoll_fd = -1;
754
755         ret = epoll_init_ctx(epoll_ev);
756         if (ret != 0) {
757                 talloc_free(epoll_ev);
758                 return ret;
759         }
760
761         ev->additional_data = epoll_ev;
762         return 0;
763 }
764
765 /*
766   destroy an fd_event
767 */
768 static int epoll_event_fd_destructor(struct tevent_fd *fde)
769 {
770         struct tevent_context *ev = fde->event_ctx;
771         struct epoll_event_context *epoll_ev = NULL;
772         bool panic_triggered = false;
773         struct tevent_fd *mpx_fde = NULL;
774         int flags = fde->flags;
775
776         if (ev == NULL) {
777                 return tevent_common_fd_destructor(fde);
778         }
779
780         epoll_ev = talloc_get_type_abort(ev->additional_data,
781                                          struct epoll_event_context);
782
783         /*
784          * we must remove the event from the list
785          * otherwise a panic fallback handler may
786          * reuse invalid memory
787          */
788         DLIST_REMOVE(ev->fd_events, fde);
789
790         if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
791                 mpx_fde = talloc_get_type_abort(fde->additional_data,
792                                                 struct tevent_fd);
793
794                 fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX;
795                 mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX;
796
797                 fde->additional_data = NULL;
798                 mpx_fde->additional_data = NULL;
799
800                 fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
801         }
802
803         epoll_ev->panic_state = &panic_triggered;
804         epoll_check_reopen(epoll_ev);
805         if (panic_triggered) {
806                 return tevent_common_fd_destructor(fde);
807         }
808
809         if (mpx_fde != NULL) {
810                 epoll_update_event(epoll_ev, mpx_fde);
811                 if (panic_triggered) {
812                         return tevent_common_fd_destructor(fde);
813                 }
814         }
815
816         fde->flags = 0;
817         epoll_update_event(epoll_ev, fde);
818         fde->flags = flags;
819         if (panic_triggered) {
820                 return tevent_common_fd_destructor(fde);
821         }
822         epoll_ev->panic_state = NULL;
823
824         return tevent_common_fd_destructor(fde);
825 }
826
827 /*
828   add a fd based event
829   return NULL on failure (memory allocation error)
830 */
831 static struct tevent_fd *epoll_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
832                                             int fd, uint16_t flags,
833                                             tevent_fd_handler_t handler,
834                                             void *private_data,
835                                             const char *handler_name,
836                                             const char *location)
837 {
838         struct epoll_event_context *epoll_ev =
839                 talloc_get_type_abort(ev->additional_data,
840                 struct epoll_event_context);
841         struct tevent_fd *fde;
842         bool panic_triggered = false;
843
844         fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
845                                    handler, private_data,
846                                    handler_name, location);
847         if (!fde) return NULL;
848
849         talloc_set_destructor(fde, epoll_event_fd_destructor);
850
851         epoll_ev->panic_state = &panic_triggered;
852         epoll_check_reopen(epoll_ev);
853         if (panic_triggered) {
854                 return fde;
855         }
856         epoll_ev->panic_state = NULL;
857
858         epoll_update_event(epoll_ev, fde);
859
860         return fde;
861 }
862
863 /*
864   set the fd event flags
865 */
866 static void epoll_event_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
867 {
868         struct tevent_context *ev;
869         struct epoll_event_context *epoll_ev;
870         bool panic_triggered = false;
871
872         if (fde->flags == flags) return;
873
874         ev = fde->event_ctx;
875         epoll_ev = talloc_get_type_abort(ev->additional_data,
876                                          struct epoll_event_context);
877
878         fde->flags = flags;
879
880         epoll_ev->panic_state = &panic_triggered;
881         epoll_check_reopen(epoll_ev);
882         if (panic_triggered) {
883                 return;
884         }
885         epoll_ev->panic_state = NULL;
886
887         epoll_update_event(epoll_ev, fde);
888 }
889
890 /*
891   do a single event loop using the events defined in ev
892 */
893 static int epoll_event_loop_once(struct tevent_context *ev, const char *location)
894 {
895         struct epoll_event_context *epoll_ev =
896                 talloc_get_type_abort(ev->additional_data,
897                 struct epoll_event_context);
898         struct timeval tval;
899         bool panic_triggered = false;
900
901         if (ev->signal_events &&
902             tevent_common_check_signal(ev)) {
903                 return 0;
904         }
905
906         if (ev->threaded_contexts != NULL) {
907                 tevent_common_threaded_activate_immediate(ev);
908         }
909
910         if (ev->immediate_events &&
911             tevent_common_loop_immediate(ev)) {
912                 return 0;
913         }
914
915         tval = tevent_common_loop_timer_delay(ev);
916         if (tevent_timeval_is_zero(&tval)) {
917                 return 0;
918         }
919
920         epoll_ev->panic_state = &panic_triggered;
921         epoll_ev->panic_force_replay = true;
922         epoll_check_reopen(epoll_ev);
923         if (panic_triggered) {
924                 errno = EINVAL;
925                 return -1;
926         }
927         epoll_ev->panic_force_replay = false;
928         epoll_ev->panic_state = NULL;
929
930         return epoll_event_loop(epoll_ev, &tval);
931 }
932
933 static const struct tevent_ops epoll_event_ops = {
934         .context_init           = epoll_event_context_init,
935         .add_fd                 = epoll_event_add_fd,
936         .set_fd_close_fn        = tevent_common_fd_set_close_fn,
937         .get_fd_flags           = tevent_common_fd_get_flags,
938         .set_fd_flags           = epoll_event_set_fd_flags,
939         .add_timer              = tevent_common_add_timer_v2,
940         .schedule_immediate     = tevent_common_schedule_immediate,
941         .add_signal             = tevent_common_add_signal,
942         .loop_once              = epoll_event_loop_once,
943         .loop_wait              = tevent_common_loop_wait,
944 };
945
946 _PRIVATE_ bool tevent_epoll_init(void)
947 {
948         return tevent_register_backend("epoll", &epoll_event_ops);
949 }