2 Unix SMB/CIFS implementation.
3 main select loop and event handling
4 Copyright (C) Andrew Tridgell 2003
5 Copyright (C) Stefan Metzmacher 2009
7 ** NOTE! The following LGPL license applies to the tevent
8 ** library. This does NOT imply that all of Samba is released
11 This library is free software; you can redistribute it and/or
12 modify it under the terms of the GNU Lesser General Public
13 License as published by the Free Software Foundation; either
14 version 3 of the License, or (at your option) any later version.
16 This library is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 Lesser General Public License for more details.
21 You should have received a copy of the GNU Lesser General Public
22 License along with this library; if not, see <http://www.gnu.org/licenses/>.
26 PLEASE READ THIS BEFORE MODIFYING!
28 This module is a general abstraction for the main select loop and
29 event handling. Do not ever put any localised hacks in here, instead
30 register one of the possible event types and implement that event
33 There are 2 types of event handling that are handled in this module:
35 1) a file descriptor becoming readable or writeable. This is mostly
36 used for network sockets, but can be used for any type of file
37 descriptor. You may only register one handler for each file
38 descriptor/io combination or you will get unpredictable results
39 (this means that you can have a handler for read events, and a
40 separate handler for write events, but not two handlers that are
41 both handling read events)
43 2) a timed event. You can register an event that happens at a
44 specific time. You can register as many of these as you
45 like. They are single shot - add a new timed event in the event
46 handler to get another event.
48 To setup a set of events you first need to create a event_context
49 structure using the function tevent_context_init(); This returns a
50 'struct tevent_context' that you use in all subsequent calls.
52 After that you can add/remove events that you are interested in
53 using tevent_add_*() and talloc_free()
55 Finally, you call tevent_loop_wait_once() to block waiting for one of the
56 events to occor or tevent_loop_wait() which will loop
61 #include "system/filesys.h"
63 #include "system/threads.h"
65 #define TEVENT_DEPRECATED 1
67 #include "tevent_internal.h"
68 #include "tevent_util.h"
70 #include <sys/eventfd.h>
73 struct tevent_ops_list
{
74 struct tevent_ops_list
*next
, *prev
;
76 const struct tevent_ops
*ops
;
79 /* list of registered event backends */
80 static struct tevent_ops_list
*tevent_backends
= NULL
;
81 static char *tevent_default_backend
= NULL
;
84 register an events backend
86 bool tevent_register_backend(const char *name
, const struct tevent_ops
*ops
)
88 struct tevent_ops_list
*e
;
90 for (e
= tevent_backends
; e
!= NULL
; e
= e
->next
) {
91 if (0 == strcmp(e
->name
, name
)) {
92 /* already registered, skip it */
97 e
= talloc(NULL
, struct tevent_ops_list
);
98 if (e
== NULL
) return false;
102 DLIST_ADD(tevent_backends
, e
);
108 set the default event backend
110 void tevent_set_default_backend(const char *backend
)
112 talloc_free(tevent_default_backend
);
113 tevent_default_backend
= talloc_strdup(NULL
, backend
);
117 initialise backends if not already done
119 static void tevent_backend_init(void)
130 tevent_poll_mt_init();
131 #if defined(HAVE_EPOLL)
133 #elif defined(HAVE_SOLARIS_PORTS)
137 tevent_standard_init();
140 _PRIVATE_
const struct tevent_ops
*tevent_find_ops_byname(const char *name
)
142 struct tevent_ops_list
*e
;
144 tevent_backend_init();
147 name
= tevent_default_backend
;
153 for (e
= tevent_backends
; e
!= NULL
; e
= e
->next
) {
154 if (0 == strcmp(e
->name
, name
)) {
163 list available backends
165 const char **tevent_backend_list(TALLOC_CTX
*mem_ctx
)
167 const char **list
= NULL
;
168 struct tevent_ops_list
*e
;
170 tevent_backend_init();
172 for (e
=tevent_backends
;e
;e
=e
->next
) {
173 list
= ev_str_list_add(list
, e
->name
);
176 talloc_steal(mem_ctx
, list
);
181 static void tevent_common_wakeup_fini(struct tevent_context
*ev
);
185 static pthread_mutex_t tevent_contexts_mutex
= PTHREAD_MUTEX_INITIALIZER
;
186 static struct tevent_context
*tevent_contexts
= NULL
;
187 static pthread_once_t tevent_atfork_initialized
= PTHREAD_ONCE_INIT
;
189 static void tevent_atfork_prepare(void)
191 struct tevent_context
*ev
;
194 ret
= pthread_mutex_lock(&tevent_contexts_mutex
);
199 for (ev
= tevent_contexts
; ev
!= NULL
; ev
= ev
->next
) {
200 struct tevent_threaded_context
*tctx
;
202 for (tctx
= ev
->threaded_contexts
; tctx
!= NULL
;
204 ret
= pthread_mutex_lock(&tctx
->event_ctx_mutex
);
206 tevent_abort(ev
, "pthread_mutex_lock failed");
210 ret
= pthread_mutex_lock(&ev
->scheduled_mutex
);
212 tevent_abort(ev
, "pthread_mutex_lock failed");
217 static void tevent_atfork_parent(void)
219 struct tevent_context
*ev
;
222 for (ev
= DLIST_TAIL(tevent_contexts
); ev
!= NULL
;
223 ev
= DLIST_PREV(ev
)) {
224 struct tevent_threaded_context
*tctx
;
226 ret
= pthread_mutex_unlock(&ev
->scheduled_mutex
);
228 tevent_abort(ev
, "pthread_mutex_unlock failed");
231 for (tctx
= DLIST_TAIL(ev
->threaded_contexts
); tctx
!= NULL
;
232 tctx
= DLIST_PREV(tctx
)) {
233 ret
= pthread_mutex_unlock(&tctx
->event_ctx_mutex
);
236 ev
, "pthread_mutex_unlock failed");
241 ret
= pthread_mutex_unlock(&tevent_contexts_mutex
);
247 static void tevent_atfork_child(void)
249 struct tevent_context
*ev
;
252 for (ev
= DLIST_TAIL(tevent_contexts
); ev
!= NULL
;
253 ev
= DLIST_PREV(ev
)) {
254 struct tevent_threaded_context
*tctx
;
256 for (tctx
= DLIST_TAIL(ev
->threaded_contexts
); tctx
!= NULL
;
257 tctx
= DLIST_PREV(tctx
)) {
258 tctx
->event_ctx
= NULL
;
260 ret
= pthread_mutex_unlock(&tctx
->event_ctx_mutex
);
263 ev
, "pthread_mutex_unlock failed");
267 ev
->threaded_contexts
= NULL
;
269 ret
= pthread_mutex_unlock(&ev
->scheduled_mutex
);
271 tevent_abort(ev
, "pthread_mutex_unlock failed");
275 ret
= pthread_mutex_unlock(&tevent_contexts_mutex
);
281 static void tevent_prep_atfork(void)
285 ret
= pthread_atfork(tevent_atfork_prepare
,
286 tevent_atfork_parent
,
287 tevent_atfork_child
);
295 int tevent_common_context_destructor(struct tevent_context
*ev
)
297 struct tevent_fd
*fd
, *fn
;
298 struct tevent_timer
*te
, *tn
;
299 struct tevent_immediate
*ie
, *in
;
300 struct tevent_signal
*se
, *sn
;
301 struct tevent_wrapper_glue
*gl
, *gn
;
306 if (ev
->wrapper
.glue
!= NULL
) {
308 "tevent_common_context_destructor() active on wrapper");
312 ret
= pthread_mutex_lock(&tevent_contexts_mutex
);
317 DLIST_REMOVE(tevent_contexts
, ev
);
319 ret
= pthread_mutex_unlock(&tevent_contexts_mutex
);
324 while (ev
->threaded_contexts
!= NULL
) {
325 struct tevent_threaded_context
*tctx
= ev
->threaded_contexts
;
327 ret
= pthread_mutex_lock(&tctx
->event_ctx_mutex
);
333 * Indicate to the thread that the tevent_context is
334 * gone. The counterpart of this is in
335 * _tevent_threaded_schedule_immediate, there we read
336 * this under the threaded_context's mutex.
339 tctx
->event_ctx
= NULL
;
341 ret
= pthread_mutex_unlock(&tctx
->event_ctx_mutex
);
346 DLIST_REMOVE(ev
->threaded_contexts
, tctx
);
349 ret
= pthread_mutex_destroy(&ev
->scheduled_mutex
);
355 for (gl
= ev
->wrapper
.list
; gl
; gl
= gn
) {
359 DLIST_REMOVE(ev
->wrapper
.list
, gl
);
362 tevent_common_wakeup_fini(ev
);
364 for (fd
= ev
->fd_events
; fd
; fd
= fn
) {
367 fd
->event_ctx
= NULL
;
368 DLIST_REMOVE(ev
->fd_events
, fd
);
371 ev
->last_zero_timer
= NULL
;
372 for (te
= ev
->timer_events
; te
; te
= tn
) {
375 te
->event_ctx
= NULL
;
376 DLIST_REMOVE(ev
->timer_events
, te
);
379 for (ie
= ev
->immediate_events
; ie
; ie
= in
) {
382 ie
->event_ctx
= NULL
;
383 ie
->cancel_fn
= NULL
;
384 DLIST_REMOVE(ev
->immediate_events
, ie
);
387 for (se
= ev
->signal_events
; se
; se
= sn
) {
390 se
->event_ctx
= NULL
;
391 DLIST_REMOVE(ev
->signal_events
, se
);
393 * This is important, Otherwise signals
394 * are handled twice in child. eg, SIGHUP.
395 * one added in parent, and another one in
396 * the child. -- BoYang
398 tevent_cleanup_pending_signal_handlers(se
);
401 /* removing nesting hook or we get an abort when nesting is
402 * not allowed. -- SSS
403 * Note that we need to leave the allowed flag at its current
404 * value, otherwise the use in tevent_re_initialise() will
405 * leave the event context with allowed forced to false, which
406 * will break users that expect nesting to be allowed
408 ev
->nesting
.level
= 0;
409 ev
->nesting
.hook_fn
= NULL
;
410 ev
->nesting
.hook_private
= NULL
;
415 static int tevent_common_context_constructor(struct tevent_context
*ev
)
421 ret
= pthread_once(&tevent_atfork_initialized
, tevent_prep_atfork
);
426 ret
= pthread_mutex_init(&ev
->scheduled_mutex
, NULL
);
431 ret
= pthread_mutex_lock(&tevent_contexts_mutex
);
433 pthread_mutex_destroy(&ev
->scheduled_mutex
);
437 DLIST_ADD(tevent_contexts
, ev
);
439 ret
= pthread_mutex_unlock(&tevent_contexts_mutex
);
445 talloc_set_destructor(ev
, tevent_common_context_destructor
);
450 void tevent_common_check_double_free(TALLOC_CTX
*ptr
, const char *reason
)
452 void *parent_ptr
= talloc_parent(ptr
);
453 size_t parent_blocks
= talloc_total_blocks(parent_ptr
);
455 if (parent_ptr
!= NULL
&& parent_blocks
== 0) {
457 * This is an implicit talloc free, as we still have a parent
458 * but it's already being destroyed. Note that
459 * talloc_total_blocks(ptr) also just returns 0 if a
460 * talloc_free(ptr) is still in progress of freeing all
466 tevent_abort(NULL
, reason
);
470 create a event_context structure for a specific implemementation.
471 This must be the first events call, and all subsequent calls pass
472 this event_context as the first element. Event handlers also
473 receive this as their first argument.
475 This function is for allowing third-party-applications to hook in gluecode
476 to their own event loop code, so that they can make async usage of our client libs
478 NOTE: use tevent_context_init() inside of samba!
480 struct tevent_context
*tevent_context_init_ops(TALLOC_CTX
*mem_ctx
,
481 const struct tevent_ops
*ops
,
482 void *additional_data
)
484 struct tevent_context
*ev
;
487 ev
= talloc_zero(mem_ctx
, struct tevent_context
);
488 if (!ev
) return NULL
;
490 ret
= tevent_common_context_constructor(ev
);
497 ev
->additional_data
= additional_data
;
499 ret
= ev
->ops
->context_init(ev
);
509 create a event_context structure. This must be the first events
510 call, and all subsequent calls pass this event_context as the first
511 element. Event handlers also receive this as their first argument.
513 struct tevent_context
*tevent_context_init_byname(TALLOC_CTX
*mem_ctx
,
516 const struct tevent_ops
*ops
;
518 ops
= tevent_find_ops_byname(name
);
523 return tevent_context_init_ops(mem_ctx
, ops
, NULL
);
528 create a event_context structure. This must be the first events
529 call, and all subsequent calls pass this event_context as the first
530 element. Event handlers also receive this as their first argument.
532 struct tevent_context
*tevent_context_init(TALLOC_CTX
*mem_ctx
)
534 return tevent_context_init_byname(mem_ctx
, NULL
);
539 return NULL on failure (memory allocation error)
541 struct tevent_fd
*_tevent_add_fd(struct tevent_context
*ev
,
545 tevent_fd_handler_t handler
,
547 const char *handler_name
,
548 const char *location
)
550 return ev
->ops
->add_fd(ev
, mem_ctx
, fd
, flags
, handler
, private_data
,
551 handler_name
, location
);
555 set a close function on the fd event
557 void tevent_fd_set_close_fn(struct tevent_fd
*fde
,
558 tevent_fd_close_fn_t close_fn
)
561 if (!fde
->event_ctx
) return;
562 fde
->event_ctx
->ops
->set_fd_close_fn(fde
, close_fn
);
565 static void tevent_fd_auto_close_fn(struct tevent_context
*ev
,
566 struct tevent_fd
*fde
,
573 void tevent_fd_set_auto_close(struct tevent_fd
*fde
)
575 tevent_fd_set_close_fn(fde
, tevent_fd_auto_close_fn
);
579 return the fd event flags
581 uint16_t tevent_fd_get_flags(struct tevent_fd
*fde
)
584 if (!fde
->event_ctx
) return 0;
585 return fde
->event_ctx
->ops
->get_fd_flags(fde
);
589 set the fd event flags
591 void tevent_fd_set_flags(struct tevent_fd
*fde
, uint16_t flags
)
594 if (!fde
->event_ctx
) return;
595 fde
->event_ctx
->ops
->set_fd_flags(fde
, flags
);
598 bool tevent_signal_support(struct tevent_context
*ev
)
600 if (ev
->ops
->add_signal
) {
606 static void (*tevent_abort_fn
)(const char *reason
);
608 void tevent_set_abort_fn(void (*abort_fn
)(const char *reason
))
610 tevent_abort_fn
= abort_fn
;
613 void tevent_abort(struct tevent_context
*ev
, const char *reason
)
616 tevent_debug(ev
, TEVENT_DEBUG_FATAL
,
617 "abort: %s\n", reason
);
620 if (!tevent_abort_fn
) {
624 tevent_abort_fn(reason
);
629 return NULL on failure
631 struct tevent_timer
*_tevent_add_timer(struct tevent_context
*ev
,
633 struct timeval next_event
,
634 tevent_timer_handler_t handler
,
636 const char *handler_name
,
637 const char *location
)
639 return ev
->ops
->add_timer(ev
, mem_ctx
, next_event
, handler
, private_data
,
640 handler_name
, location
);
644 allocate an immediate event
645 return NULL on failure (memory allocation error)
647 struct tevent_immediate
*_tevent_create_immediate(TALLOC_CTX
*mem_ctx
,
648 const char *location
)
650 struct tevent_immediate
*im
;
652 im
= talloc(mem_ctx
, struct tevent_immediate
);
653 if (im
== NULL
) return NULL
;
655 *im
= (struct tevent_immediate
) { .create_location
= location
};
661 schedule an immediate event
663 void _tevent_schedule_immediate(struct tevent_immediate
*im
,
664 struct tevent_context
*ev
,
665 tevent_immediate_handler_t handler
,
667 const char *handler_name
,
668 const char *location
)
670 ev
->ops
->schedule_immediate(im
, ev
, handler
, private_data
,
671 handler_name
, location
);
677 sa_flags are flags to sigaction(2)
679 return NULL on failure
681 struct tevent_signal
*_tevent_add_signal(struct tevent_context
*ev
,
685 tevent_signal_handler_t handler
,
687 const char *handler_name
,
688 const char *location
)
690 return ev
->ops
->add_signal(ev
, mem_ctx
, signum
, sa_flags
, handler
, private_data
,
691 handler_name
, location
);
694 void tevent_loop_allow_nesting(struct tevent_context
*ev
)
696 if (ev
->wrapper
.glue
!= NULL
) {
697 tevent_abort(ev
, "tevent_loop_allow_nesting() on wrapper");
701 if (ev
->wrapper
.list
!= NULL
) {
702 tevent_abort(ev
, "tevent_loop_allow_nesting() with wrapper");
706 ev
->nesting
.allowed
= true;
709 void tevent_loop_set_nesting_hook(struct tevent_context
*ev
,
710 tevent_nesting_hook hook
,
713 if (ev
->nesting
.hook_fn
&&
714 (ev
->nesting
.hook_fn
!= hook
||
715 ev
->nesting
.hook_private
!= private_data
)) {
716 /* the way the nesting hook code is currently written
717 we cannot support two different nesting hooks at the
719 tevent_abort(ev
, "tevent: Violation of nesting hook rules\n");
721 ev
->nesting
.hook_fn
= hook
;
722 ev
->nesting
.hook_private
= private_data
;
725 static void tevent_abort_nesting(struct tevent_context
*ev
, const char *location
)
729 reason
= talloc_asprintf(NULL
, "tevent_loop_once() nesting at %s",
732 reason
= "tevent_loop_once() nesting";
735 tevent_abort(ev
, reason
);
739 do a single event loop using the events defined in ev
741 int _tevent_loop_once(struct tevent_context
*ev
, const char *location
)
744 void *nesting_stack_ptr
= NULL
;
748 if (ev
->nesting
.level
> 1) {
749 if (!ev
->nesting
.allowed
) {
750 tevent_abort_nesting(ev
, location
);
755 if (ev
->nesting
.level
> 0) {
756 if (ev
->nesting
.hook_fn
) {
758 ret2
= ev
->nesting
.hook_fn(ev
,
759 ev
->nesting
.hook_private
,
762 (void *)&nesting_stack_ptr
,
771 tevent_trace_point_callback(ev
, TEVENT_TRACE_BEFORE_LOOP_ONCE
);
772 ret
= ev
->ops
->loop_once(ev
, location
);
773 tevent_trace_point_callback(ev
, TEVENT_TRACE_AFTER_LOOP_ONCE
);
775 if (ev
->nesting
.level
> 0) {
776 if (ev
->nesting
.hook_fn
) {
778 ret2
= ev
->nesting
.hook_fn(ev
,
779 ev
->nesting
.hook_private
,
782 (void *)&nesting_stack_ptr
,
797 this is a performance optimization for the samba4 nested event loop problems
799 int _tevent_loop_until(struct tevent_context
*ev
,
800 bool (*finished
)(void *private_data
),
802 const char *location
)
805 void *nesting_stack_ptr
= NULL
;
809 if (ev
->nesting
.level
> 1) {
810 if (!ev
->nesting
.allowed
) {
811 tevent_abort_nesting(ev
, location
);
816 if (ev
->nesting
.level
> 0) {
817 if (ev
->nesting
.hook_fn
) {
819 ret2
= ev
->nesting
.hook_fn(ev
,
820 ev
->nesting
.hook_private
,
823 (void *)&nesting_stack_ptr
,
832 while (!finished(private_data
)) {
833 tevent_trace_point_callback(ev
, TEVENT_TRACE_BEFORE_LOOP_ONCE
);
834 ret
= ev
->ops
->loop_once(ev
, location
);
835 tevent_trace_point_callback(ev
, TEVENT_TRACE_AFTER_LOOP_ONCE
);
841 if (ev
->nesting
.level
> 0) {
842 if (ev
->nesting
.hook_fn
) {
844 ret2
= ev
->nesting
.hook_fn(ev
,
845 ev
->nesting
.hook_private
,
848 (void *)&nesting_stack_ptr
,
862 bool tevent_common_have_events(struct tevent_context
*ev
)
864 if (ev
->fd_events
!= NULL
) {
865 if (ev
->fd_events
!= ev
->wakeup_fde
) {
868 if (ev
->fd_events
->next
!= NULL
) {
873 * At this point we just have the wakeup pipe event as
874 * the only fd_event. That one does not count as a
875 * regular event, so look at the other event types.
879 return ((ev
->timer_events
!= NULL
) ||
880 (ev
->immediate_events
!= NULL
) ||
881 (ev
->signal_events
!= NULL
));
885 return on failure or (with 0) if all fd events are removed
887 int tevent_common_loop_wait(struct tevent_context
*ev
,
888 const char *location
)
891 * loop as long as we have events pending
893 while (tevent_common_have_events(ev
)) {
895 ret
= _tevent_loop_once(ev
, location
);
897 tevent_debug(ev
, TEVENT_DEBUG_FATAL
,
898 "_tevent_loop_once() failed: %d - %s\n",
899 ret
, strerror(errno
));
904 tevent_debug(ev
, TEVENT_DEBUG_WARNING
,
905 "tevent_common_loop_wait() out of events\n");
910 return on failure or (with 0) if all fd events are removed
912 int _tevent_loop_wait(struct tevent_context
*ev
, const char *location
)
914 return ev
->ops
->loop_wait(ev
, location
);
919 re-initialise a tevent context. This leaves you with the same
920 event context, but all events are wiped and the structure is
921 re-initialised. This is most useful after a fork()
923 zero is returned on success, non-zero on failure
925 int tevent_re_initialise(struct tevent_context
*ev
)
927 tevent_common_context_destructor(ev
);
929 tevent_common_context_constructor(ev
);
931 return ev
->ops
->context_init(ev
);
934 static void wakeup_pipe_handler(struct tevent_context
*ev
,
935 struct tevent_fd
*fde
,
936 uint16_t flags
, void *_private
)
942 * This is the boilerplate for eventfd, but it works
943 * for pipes too. And as we don't care about the data
944 * we read, we're fine.
947 ret
= read(fde
->fd
, &val
, sizeof(val
));
948 } while (ret
== -1 && errno
== EINTR
);
952 * Initialize the wakeup pipe and pipe fde
955 int tevent_common_wakeup_init(struct tevent_context
*ev
)
959 if (ev
->wakeup_fde
!= NULL
) {
964 ret
= eventfd(0, EFD_NONBLOCK
);
968 read_fd
= ev
->wakeup_fd
= ret
;
972 ret
= pipe(pipe_fds
);
976 ev
->wakeup_fd
= pipe_fds
[1];
977 ev
->wakeup_read_fd
= pipe_fds
[0];
979 ev_set_blocking(ev
->wakeup_fd
, false);
980 ev_set_blocking(ev
->wakeup_read_fd
, false);
982 read_fd
= ev
->wakeup_read_fd
;
986 ev
->wakeup_fde
= tevent_add_fd(ev
, ev
, read_fd
, TEVENT_FD_READ
,
987 wakeup_pipe_handler
, NULL
);
988 if (ev
->wakeup_fde
== NULL
) {
989 close(ev
->wakeup_fd
);
991 close(ev
->wakeup_read_fd
);
999 int tevent_common_wakeup_fd(int fd
)
1006 ret
= write(fd
, &val
, sizeof(val
));
1009 ret
= write(fd
, &c
, 1);
1011 } while ((ret
== -1) && (errno
== EINTR
));
1016 int tevent_common_wakeup(struct tevent_context
*ev
)
1018 if (ev
->wakeup_fde
== NULL
) {
1022 return tevent_common_wakeup_fd(ev
->wakeup_fd
);
1025 static void tevent_common_wakeup_fini(struct tevent_context
*ev
)
1027 if (ev
->wakeup_fde
== NULL
) {
1031 TALLOC_FREE(ev
->wakeup_fde
);
1033 close(ev
->wakeup_fd
);
1034 #ifndef HAVE_EVENTFD
1035 close(ev
->wakeup_read_fd
);