source: vendor/current/lib/tevent/tevent_epoll.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 24.8 KB
Line 
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
35struct 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
56static 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
72static 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
89static 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*/
133static 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*/
174static 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*/
185static 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*/
195static 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
215static 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 */
222static 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
268static 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*/
356static 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*/
428static 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*/
480static 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
542static 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*/
593static 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*/
623static 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*/
739static 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*/
768static 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*/
831static 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*/
866static 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*/
893static 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->immediate_events &&
907 tevent_common_loop_immediate(ev)) {
908 return 0;
909 }
910
911 tval = tevent_common_loop_timer_delay(ev);
912 if (tevent_timeval_is_zero(&tval)) {
913 return 0;
914 }
915
916 epoll_ev->panic_state = &panic_triggered;
917 epoll_ev->panic_force_replay = true;
918 epoll_check_reopen(epoll_ev);
919 if (panic_triggered) {
920 errno = EINVAL;
921 return -1;
922 }
923 epoll_ev->panic_force_replay = false;
924 epoll_ev->panic_state = NULL;
925
926 return epoll_event_loop(epoll_ev, &tval);
927}
928
929static const struct tevent_ops epoll_event_ops = {
930 .context_init = epoll_event_context_init,
931 .add_fd = epoll_event_add_fd,
932 .set_fd_close_fn = tevent_common_fd_set_close_fn,
933 .get_fd_flags = tevent_common_fd_get_flags,
934 .set_fd_flags = epoll_event_set_fd_flags,
935 .add_timer = tevent_common_add_timer_v2,
936 .schedule_immediate = tevent_common_schedule_immediate,
937 .add_signal = tevent_common_add_signal,
938 .loop_once = epoll_event_loop_once,
939 .loop_wait = tevent_common_loop_wait,
940};
941
942_PRIVATE_ bool tevent_epoll_init(void)
943{
944 return tevent_register_backend("epoll", &epoll_event_ops);
945}
Note: See TracBrowser for help on using the repository browser.