mirror of
https://github.com/samba-team/samba.git
synced 2024-12-23 17:34:34 +03:00
2d55883e28
Purely cosmetic change: This moves closing the signal/thread event pipe to where it's opened. This prepares the eventfd support, making the "magic" for eventfd more obvious. Signed-off-by: Volker Lendecke <vl@samba.org> Reviewed-by: Stefan Metzmacher <metze@samba.org> Reviewed-by: Jeremy Allison <jra@samba.org>
908 lines
20 KiB
C
908 lines
20 KiB
C
/*
|
|
Unix SMB/CIFS implementation.
|
|
main select loop and event handling
|
|
Copyright (C) Andrew Tridgell 2003
|
|
Copyright (C) Stefan Metzmacher 2009
|
|
|
|
** NOTE! The following LGPL license applies to the tevent
|
|
** library. This does NOT imply that all of Samba is released
|
|
** under the LGPL
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 3 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/*
|
|
PLEASE READ THIS BEFORE MODIFYING!
|
|
|
|
This module is a general abstraction for the main select loop and
|
|
event handling. Do not ever put any localised hacks in here, instead
|
|
register one of the possible event types and implement that event
|
|
somewhere else.
|
|
|
|
There are 2 types of event handling that are handled in this module:
|
|
|
|
1) a file descriptor becoming readable or writeable. This is mostly
|
|
used for network sockets, but can be used for any type of file
|
|
descriptor. You may only register one handler for each file
|
|
descriptor/io combination or you will get unpredictable results
|
|
(this means that you can have a handler for read events, and a
|
|
separate handler for write events, but not two handlers that are
|
|
both handling read events)
|
|
|
|
2) a timed event. You can register an event that happens at a
|
|
specific time. You can register as many of these as you
|
|
like. They are single shot - add a new timed event in the event
|
|
handler to get another event.
|
|
|
|
To setup a set of events you first need to create a event_context
|
|
structure using the function tevent_context_init(); This returns a
|
|
'struct tevent_context' that you use in all subsequent calls.
|
|
|
|
After that you can add/remove events that you are interested in
|
|
using tevent_add_*() and talloc_free()
|
|
|
|
Finally, you call tevent_loop_wait_once() to block waiting for one of the
|
|
events to occor or tevent_loop_wait() which will loop
|
|
forever.
|
|
|
|
*/
|
|
#include "replace.h"
|
|
#include "system/filesys.h"
|
|
#ifdef HAVE_PTHREAD
|
|
#include "system/threads.h"
|
|
#endif
|
|
#define TEVENT_DEPRECATED 1
|
|
#include "tevent.h"
|
|
#include "tevent_internal.h"
|
|
#include "tevent_util.h"
|
|
|
|
static void tevent_abort(struct tevent_context *ev, const char *reason);
|
|
|
|
struct tevent_ops_list {
|
|
struct tevent_ops_list *next, *prev;
|
|
const char *name;
|
|
const struct tevent_ops *ops;
|
|
};
|
|
|
|
/* list of registered event backends */
|
|
static struct tevent_ops_list *tevent_backends = NULL;
|
|
static char *tevent_default_backend = NULL;
|
|
|
|
/*
|
|
register an events backend
|
|
*/
|
|
bool tevent_register_backend(const char *name, const struct tevent_ops *ops)
|
|
{
|
|
struct tevent_ops_list *e;
|
|
|
|
for (e = tevent_backends; e != NULL; e = e->next) {
|
|
if (0 == strcmp(e->name, name)) {
|
|
/* already registered, skip it */
|
|
return true;
|
|
}
|
|
}
|
|
|
|
e = talloc(NULL, struct tevent_ops_list);
|
|
if (e == NULL) return false;
|
|
|
|
e->name = name;
|
|
e->ops = ops;
|
|
DLIST_ADD(tevent_backends, e);
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
set the default event backend
|
|
*/
|
|
void tevent_set_default_backend(const char *backend)
|
|
{
|
|
talloc_free(tevent_default_backend);
|
|
tevent_default_backend = talloc_strdup(NULL, backend);
|
|
}
|
|
|
|
/*
|
|
initialise backends if not already done
|
|
*/
|
|
static void tevent_backend_init(void)
|
|
{
|
|
static bool done;
|
|
|
|
if (done) {
|
|
return;
|
|
}
|
|
|
|
done = true;
|
|
|
|
tevent_select_init();
|
|
tevent_poll_init();
|
|
tevent_poll_mt_init();
|
|
#if defined(HAVE_EPOLL)
|
|
tevent_epoll_init();
|
|
#elif defined(HAVE_SOLARIS_PORTS)
|
|
tevent_port_init();
|
|
#endif
|
|
|
|
tevent_standard_init();
|
|
}
|
|
|
|
_PRIVATE_ const struct tevent_ops *tevent_find_ops_byname(const char *name)
|
|
{
|
|
struct tevent_ops_list *e;
|
|
|
|
tevent_backend_init();
|
|
|
|
if (name == NULL) {
|
|
name = tevent_default_backend;
|
|
}
|
|
if (name == NULL) {
|
|
name = "standard";
|
|
}
|
|
|
|
for (e = tevent_backends; e != NULL; e = e->next) {
|
|
if (0 == strcmp(e->name, name)) {
|
|
return e->ops;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
list available backends
|
|
*/
|
|
const char **tevent_backend_list(TALLOC_CTX *mem_ctx)
|
|
{
|
|
const char **list = NULL;
|
|
struct tevent_ops_list *e;
|
|
|
|
tevent_backend_init();
|
|
|
|
for (e=tevent_backends;e;e=e->next) {
|
|
list = ev_str_list_add(list, e->name);
|
|
}
|
|
|
|
talloc_steal(mem_ctx, list);
|
|
|
|
return list;
|
|
}
|
|
|
|
static void tevent_common_wakeup_fini(struct tevent_context *ev);
|
|
|
|
#ifdef HAVE_PTHREAD
|
|
|
|
static pthread_mutex_t tevent_contexts_mutex = PTHREAD_MUTEX_INITIALIZER;
|
|
static struct tevent_context *tevent_contexts = NULL;
|
|
static pthread_once_t tevent_atfork_initialized = PTHREAD_ONCE_INIT;
|
|
|
|
static void tevent_atfork_prepare(void)
|
|
{
|
|
struct tevent_context *ev;
|
|
int ret;
|
|
|
|
ret = pthread_mutex_lock(&tevent_contexts_mutex);
|
|
if (ret != 0) {
|
|
abort();
|
|
}
|
|
|
|
for (ev = tevent_contexts; ev != NULL; ev = ev->next) {
|
|
ret = pthread_mutex_lock(&ev->scheduled_mutex);
|
|
if (ret != 0) {
|
|
tevent_abort(ev, "pthread_mutex_lock failed");
|
|
}
|
|
}
|
|
}
|
|
|
|
static void tevent_atfork_parent(void)
|
|
{
|
|
struct tevent_context *ev;
|
|
int ret;
|
|
|
|
for (ev = DLIST_TAIL(tevent_contexts); ev != NULL;
|
|
ev = DLIST_PREV(ev)) {
|
|
ret = pthread_mutex_unlock(&ev->scheduled_mutex);
|
|
if (ret != 0) {
|
|
tevent_abort(ev, "pthread_mutex_unlock failed");
|
|
}
|
|
}
|
|
|
|
ret = pthread_mutex_unlock(&tevent_contexts_mutex);
|
|
if (ret != 0) {
|
|
abort();
|
|
}
|
|
}
|
|
|
|
static void tevent_atfork_child(void)
|
|
{
|
|
struct tevent_context *ev;
|
|
int ret;
|
|
|
|
for (ev = DLIST_TAIL(tevent_contexts); ev != NULL;
|
|
ev = DLIST_PREV(ev)) {
|
|
struct tevent_threaded_context *tctx;
|
|
|
|
for (tctx = ev->threaded_contexts; tctx != NULL;
|
|
tctx = tctx->next) {
|
|
tctx->event_ctx = NULL;
|
|
}
|
|
|
|
ev->threaded_contexts = NULL;
|
|
|
|
ret = pthread_mutex_unlock(&ev->scheduled_mutex);
|
|
if (ret != 0) {
|
|
tevent_abort(ev, "pthread_mutex_unlock failed");
|
|
}
|
|
}
|
|
|
|
ret = pthread_mutex_unlock(&tevent_contexts_mutex);
|
|
if (ret != 0) {
|
|
abort();
|
|
}
|
|
}
|
|
|
|
static void tevent_prep_atfork(void)
|
|
{
|
|
int ret;
|
|
|
|
ret = pthread_atfork(tevent_atfork_prepare,
|
|
tevent_atfork_parent,
|
|
tevent_atfork_child);
|
|
if (ret != 0) {
|
|
abort();
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
int tevent_common_context_destructor(struct tevent_context *ev)
|
|
{
|
|
struct tevent_fd *fd, *fn;
|
|
struct tevent_timer *te, *tn;
|
|
struct tevent_immediate *ie, *in;
|
|
struct tevent_signal *se, *sn;
|
|
|
|
#ifdef HAVE_PTHREAD
|
|
int ret;
|
|
|
|
ret = pthread_mutex_lock(&tevent_contexts_mutex);
|
|
if (ret != 0) {
|
|
abort();
|
|
}
|
|
|
|
DLIST_REMOVE(tevent_contexts, ev);
|
|
|
|
ret = pthread_mutex_unlock(&tevent_contexts_mutex);
|
|
if (ret != 0) {
|
|
abort();
|
|
}
|
|
#endif
|
|
|
|
if (ev->threaded_contexts != NULL) {
|
|
/*
|
|
* Threaded contexts are indicators that threads are
|
|
* about to send us immediates via
|
|
* tevent_threaded_schedule_immediate. The caller
|
|
* needs to make sure that the tevent context lives
|
|
* long enough to receive immediates from all threads.
|
|
*/
|
|
tevent_abort(ev, "threaded contexts exist");
|
|
}
|
|
|
|
tevent_common_wakeup_fini(ev);
|
|
|
|
for (fd = ev->fd_events; fd; fd = fn) {
|
|
fn = fd->next;
|
|
fd->event_ctx = NULL;
|
|
DLIST_REMOVE(ev->fd_events, fd);
|
|
}
|
|
|
|
ev->last_zero_timer = NULL;
|
|
for (te = ev->timer_events; te; te = tn) {
|
|
tn = te->next;
|
|
te->event_ctx = NULL;
|
|
DLIST_REMOVE(ev->timer_events, te);
|
|
}
|
|
|
|
for (ie = ev->immediate_events; ie; ie = in) {
|
|
in = ie->next;
|
|
ie->event_ctx = NULL;
|
|
ie->cancel_fn = NULL;
|
|
DLIST_REMOVE(ev->immediate_events, ie);
|
|
}
|
|
|
|
for (se = ev->signal_events; se; se = sn) {
|
|
sn = se->next;
|
|
se->event_ctx = NULL;
|
|
DLIST_REMOVE(ev->signal_events, se);
|
|
/*
|
|
* This is important, Otherwise signals
|
|
* are handled twice in child. eg, SIGHUP.
|
|
* one added in parent, and another one in
|
|
* the child. -- BoYang
|
|
*/
|
|
tevent_cleanup_pending_signal_handlers(se);
|
|
}
|
|
|
|
/* removing nesting hook or we get an abort when nesting is
|
|
* not allowed. -- SSS
|
|
* Note that we need to leave the allowed flag at its current
|
|
* value, otherwise the use in tevent_re_initialise() will
|
|
* leave the event context with allowed forced to false, which
|
|
* will break users that expect nesting to be allowed
|
|
*/
|
|
ev->nesting.level = 0;
|
|
ev->nesting.hook_fn = NULL;
|
|
ev->nesting.hook_private = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
create a event_context structure for a specific implemementation.
|
|
This must be the first events call, and all subsequent calls pass
|
|
this event_context as the first element. Event handlers also
|
|
receive this as their first argument.
|
|
|
|
This function is for allowing third-party-applications to hook in gluecode
|
|
to their own event loop code, so that they can make async usage of our client libs
|
|
|
|
NOTE: use tevent_context_init() inside of samba!
|
|
*/
|
|
struct tevent_context *tevent_context_init_ops(TALLOC_CTX *mem_ctx,
|
|
const struct tevent_ops *ops,
|
|
void *additional_data)
|
|
{
|
|
struct tevent_context *ev;
|
|
int ret;
|
|
|
|
ev = talloc_zero(mem_ctx, struct tevent_context);
|
|
if (!ev) return NULL;
|
|
|
|
#ifdef HAVE_PTHREAD
|
|
|
|
ret = pthread_once(&tevent_atfork_initialized, tevent_prep_atfork);
|
|
if (ret != 0) {
|
|
talloc_free(ev);
|
|
return NULL;
|
|
}
|
|
|
|
ret = pthread_mutex_init(&ev->scheduled_mutex, NULL);
|
|
if (ret != 0) {
|
|
talloc_free(ev);
|
|
return NULL;
|
|
}
|
|
|
|
ret = pthread_mutex_lock(&tevent_contexts_mutex);
|
|
if (ret != 0) {
|
|
pthread_mutex_destroy(&ev->scheduled_mutex);
|
|
talloc_free(ev);
|
|
return NULL;
|
|
}
|
|
|
|
DLIST_ADD(tevent_contexts, ev);
|
|
|
|
ret = pthread_mutex_unlock(&tevent_contexts_mutex);
|
|
if (ret != 0) {
|
|
abort();
|
|
}
|
|
|
|
#endif
|
|
|
|
talloc_set_destructor(ev, tevent_common_context_destructor);
|
|
|
|
ev->ops = ops;
|
|
ev->additional_data = additional_data;
|
|
|
|
ret = ev->ops->context_init(ev);
|
|
if (ret != 0) {
|
|
talloc_free(ev);
|
|
return NULL;
|
|
}
|
|
|
|
return ev;
|
|
}
|
|
|
|
/*
|
|
create a event_context structure. This must be the first events
|
|
call, and all subsequent calls pass this event_context as the first
|
|
element. Event handlers also receive this as their first argument.
|
|
*/
|
|
struct tevent_context *tevent_context_init_byname(TALLOC_CTX *mem_ctx,
|
|
const char *name)
|
|
{
|
|
const struct tevent_ops *ops;
|
|
|
|
ops = tevent_find_ops_byname(name);
|
|
if (ops == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
return tevent_context_init_ops(mem_ctx, ops, NULL);
|
|
}
|
|
|
|
|
|
/*
|
|
create a event_context structure. This must be the first events
|
|
call, and all subsequent calls pass this event_context as the first
|
|
element. Event handlers also receive this as their first argument.
|
|
*/
|
|
struct tevent_context *tevent_context_init(TALLOC_CTX *mem_ctx)
|
|
{
|
|
return tevent_context_init_byname(mem_ctx, NULL);
|
|
}
|
|
|
|
/*
|
|
add a fd based event
|
|
return NULL on failure (memory allocation error)
|
|
*/
|
|
struct tevent_fd *_tevent_add_fd(struct tevent_context *ev,
|
|
TALLOC_CTX *mem_ctx,
|
|
int fd,
|
|
uint16_t flags,
|
|
tevent_fd_handler_t handler,
|
|
void *private_data,
|
|
const char *handler_name,
|
|
const char *location)
|
|
{
|
|
return ev->ops->add_fd(ev, mem_ctx, fd, flags, handler, private_data,
|
|
handler_name, location);
|
|
}
|
|
|
|
/*
|
|
set a close function on the fd event
|
|
*/
|
|
void tevent_fd_set_close_fn(struct tevent_fd *fde,
|
|
tevent_fd_close_fn_t close_fn)
|
|
{
|
|
if (!fde) return;
|
|
if (!fde->event_ctx) return;
|
|
fde->event_ctx->ops->set_fd_close_fn(fde, close_fn);
|
|
}
|
|
|
|
static void tevent_fd_auto_close_fn(struct tevent_context *ev,
|
|
struct tevent_fd *fde,
|
|
int fd,
|
|
void *private_data)
|
|
{
|
|
close(fd);
|
|
}
|
|
|
|
void tevent_fd_set_auto_close(struct tevent_fd *fde)
|
|
{
|
|
tevent_fd_set_close_fn(fde, tevent_fd_auto_close_fn);
|
|
}
|
|
|
|
/*
|
|
return the fd event flags
|
|
*/
|
|
uint16_t tevent_fd_get_flags(struct tevent_fd *fde)
|
|
{
|
|
if (!fde) return 0;
|
|
if (!fde->event_ctx) return 0;
|
|
return fde->event_ctx->ops->get_fd_flags(fde);
|
|
}
|
|
|
|
/*
|
|
set the fd event flags
|
|
*/
|
|
void tevent_fd_set_flags(struct tevent_fd *fde, uint16_t flags)
|
|
{
|
|
if (!fde) return;
|
|
if (!fde->event_ctx) return;
|
|
fde->event_ctx->ops->set_fd_flags(fde, flags);
|
|
}
|
|
|
|
bool tevent_signal_support(struct tevent_context *ev)
|
|
{
|
|
if (ev->ops->add_signal) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void (*tevent_abort_fn)(const char *reason);
|
|
|
|
void tevent_set_abort_fn(void (*abort_fn)(const char *reason))
|
|
{
|
|
tevent_abort_fn = abort_fn;
|
|
}
|
|
|
|
static void tevent_abort(struct tevent_context *ev, const char *reason)
|
|
{
|
|
tevent_debug(ev, TEVENT_DEBUG_FATAL,
|
|
"abort: %s\n", reason);
|
|
|
|
if (!tevent_abort_fn) {
|
|
abort();
|
|
}
|
|
|
|
tevent_abort_fn(reason);
|
|
}
|
|
|
|
/*
|
|
add a timer event
|
|
return NULL on failure
|
|
*/
|
|
struct tevent_timer *_tevent_add_timer(struct tevent_context *ev,
|
|
TALLOC_CTX *mem_ctx,
|
|
struct timeval next_event,
|
|
tevent_timer_handler_t handler,
|
|
void *private_data,
|
|
const char *handler_name,
|
|
const char *location)
|
|
{
|
|
return ev->ops->add_timer(ev, mem_ctx, next_event, handler, private_data,
|
|
handler_name, location);
|
|
}
|
|
|
|
/*
|
|
allocate an immediate event
|
|
return NULL on failure (memory allocation error)
|
|
*/
|
|
struct tevent_immediate *_tevent_create_immediate(TALLOC_CTX *mem_ctx,
|
|
const char *location)
|
|
{
|
|
struct tevent_immediate *im;
|
|
|
|
im = talloc(mem_ctx, struct tevent_immediate);
|
|
if (im == NULL) return NULL;
|
|
|
|
im->prev = NULL;
|
|
im->next = NULL;
|
|
im->event_ctx = NULL;
|
|
im->create_location = location;
|
|
im->handler = NULL;
|
|
im->private_data = NULL;
|
|
im->handler_name = NULL;
|
|
im->schedule_location = NULL;
|
|
im->cancel_fn = NULL;
|
|
im->additional_data = NULL;
|
|
|
|
return im;
|
|
}
|
|
|
|
/*
|
|
schedule an immediate event
|
|
*/
|
|
void _tevent_schedule_immediate(struct tevent_immediate *im,
|
|
struct tevent_context *ev,
|
|
tevent_immediate_handler_t handler,
|
|
void *private_data,
|
|
const char *handler_name,
|
|
const char *location)
|
|
{
|
|
ev->ops->schedule_immediate(im, ev, handler, private_data,
|
|
handler_name, location);
|
|
}
|
|
|
|
/*
|
|
add a signal event
|
|
|
|
sa_flags are flags to sigaction(2)
|
|
|
|
return NULL on failure
|
|
*/
|
|
struct tevent_signal *_tevent_add_signal(struct tevent_context *ev,
|
|
TALLOC_CTX *mem_ctx,
|
|
int signum,
|
|
int sa_flags,
|
|
tevent_signal_handler_t handler,
|
|
void *private_data,
|
|
const char *handler_name,
|
|
const char *location)
|
|
{
|
|
return ev->ops->add_signal(ev, mem_ctx, signum, sa_flags, handler, private_data,
|
|
handler_name, location);
|
|
}
|
|
|
|
void tevent_loop_allow_nesting(struct tevent_context *ev)
|
|
{
|
|
ev->nesting.allowed = true;
|
|
}
|
|
|
|
void tevent_loop_set_nesting_hook(struct tevent_context *ev,
|
|
tevent_nesting_hook hook,
|
|
void *private_data)
|
|
{
|
|
if (ev->nesting.hook_fn &&
|
|
(ev->nesting.hook_fn != hook ||
|
|
ev->nesting.hook_private != private_data)) {
|
|
/* the way the nesting hook code is currently written
|
|
we cannot support two different nesting hooks at the
|
|
same time. */
|
|
tevent_abort(ev, "tevent: Violation of nesting hook rules\n");
|
|
}
|
|
ev->nesting.hook_fn = hook;
|
|
ev->nesting.hook_private = private_data;
|
|
}
|
|
|
|
static void tevent_abort_nesting(struct tevent_context *ev, const char *location)
|
|
{
|
|
const char *reason;
|
|
|
|
reason = talloc_asprintf(NULL, "tevent_loop_once() nesting at %s",
|
|
location);
|
|
if (!reason) {
|
|
reason = "tevent_loop_once() nesting";
|
|
}
|
|
|
|
tevent_abort(ev, reason);
|
|
}
|
|
|
|
/*
|
|
do a single event loop using the events defined in ev
|
|
*/
|
|
int _tevent_loop_once(struct tevent_context *ev, const char *location)
|
|
{
|
|
int ret;
|
|
void *nesting_stack_ptr = NULL;
|
|
|
|
ev->nesting.level++;
|
|
|
|
if (ev->nesting.level > 1) {
|
|
if (!ev->nesting.allowed) {
|
|
tevent_abort_nesting(ev, location);
|
|
errno = ELOOP;
|
|
return -1;
|
|
}
|
|
}
|
|
if (ev->nesting.level > 0) {
|
|
if (ev->nesting.hook_fn) {
|
|
int ret2;
|
|
ret2 = ev->nesting.hook_fn(ev,
|
|
ev->nesting.hook_private,
|
|
ev->nesting.level,
|
|
true,
|
|
(void *)&nesting_stack_ptr,
|
|
location);
|
|
if (ret2 != 0) {
|
|
ret = ret2;
|
|
goto done;
|
|
}
|
|
}
|
|
}
|
|
|
|
tevent_trace_point_callback(ev, TEVENT_TRACE_BEFORE_LOOP_ONCE);
|
|
ret = ev->ops->loop_once(ev, location);
|
|
tevent_trace_point_callback(ev, TEVENT_TRACE_AFTER_LOOP_ONCE);
|
|
|
|
if (ev->nesting.level > 0) {
|
|
if (ev->nesting.hook_fn) {
|
|
int ret2;
|
|
ret2 = ev->nesting.hook_fn(ev,
|
|
ev->nesting.hook_private,
|
|
ev->nesting.level,
|
|
false,
|
|
(void *)&nesting_stack_ptr,
|
|
location);
|
|
if (ret2 != 0) {
|
|
ret = ret2;
|
|
goto done;
|
|
}
|
|
}
|
|
}
|
|
|
|
done:
|
|
ev->nesting.level--;
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
this is a performance optimization for the samba4 nested event loop problems
|
|
*/
|
|
int _tevent_loop_until(struct tevent_context *ev,
|
|
bool (*finished)(void *private_data),
|
|
void *private_data,
|
|
const char *location)
|
|
{
|
|
int ret = 0;
|
|
void *nesting_stack_ptr = NULL;
|
|
|
|
ev->nesting.level++;
|
|
|
|
if (ev->nesting.level > 1) {
|
|
if (!ev->nesting.allowed) {
|
|
tevent_abort_nesting(ev, location);
|
|
errno = ELOOP;
|
|
return -1;
|
|
}
|
|
}
|
|
if (ev->nesting.level > 0) {
|
|
if (ev->nesting.hook_fn) {
|
|
int ret2;
|
|
ret2 = ev->nesting.hook_fn(ev,
|
|
ev->nesting.hook_private,
|
|
ev->nesting.level,
|
|
true,
|
|
(void *)&nesting_stack_ptr,
|
|
location);
|
|
if (ret2 != 0) {
|
|
ret = ret2;
|
|
goto done;
|
|
}
|
|
}
|
|
}
|
|
|
|
while (!finished(private_data)) {
|
|
tevent_trace_point_callback(ev, TEVENT_TRACE_BEFORE_LOOP_ONCE);
|
|
ret = ev->ops->loop_once(ev, location);
|
|
tevent_trace_point_callback(ev, TEVENT_TRACE_AFTER_LOOP_ONCE);
|
|
if (ret != 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ev->nesting.level > 0) {
|
|
if (ev->nesting.hook_fn) {
|
|
int ret2;
|
|
ret2 = ev->nesting.hook_fn(ev,
|
|
ev->nesting.hook_private,
|
|
ev->nesting.level,
|
|
false,
|
|
(void *)&nesting_stack_ptr,
|
|
location);
|
|
if (ret2 != 0) {
|
|
ret = ret2;
|
|
goto done;
|
|
}
|
|
}
|
|
}
|
|
|
|
done:
|
|
ev->nesting.level--;
|
|
return ret;
|
|
}
|
|
|
|
bool tevent_common_have_events(struct tevent_context *ev)
|
|
{
|
|
if (ev->fd_events != NULL) {
|
|
if (ev->fd_events != ev->pipe_fde) {
|
|
return true;
|
|
}
|
|
if (ev->fd_events->next != NULL) {
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* At this point we just have the wakeup pipe event as
|
|
* the only fd_event. That one does not count as a
|
|
* regular event, so look at the other event types.
|
|
*/
|
|
}
|
|
|
|
return ((ev->timer_events != NULL) ||
|
|
(ev->immediate_events != NULL) ||
|
|
(ev->signal_events != NULL));
|
|
}
|
|
|
|
/*
|
|
return on failure or (with 0) if all fd events are removed
|
|
*/
|
|
int tevent_common_loop_wait(struct tevent_context *ev,
|
|
const char *location)
|
|
{
|
|
/*
|
|
* loop as long as we have events pending
|
|
*/
|
|
while (tevent_common_have_events(ev)) {
|
|
int ret;
|
|
ret = _tevent_loop_once(ev, location);
|
|
if (ret != 0) {
|
|
tevent_debug(ev, TEVENT_DEBUG_FATAL,
|
|
"_tevent_loop_once() failed: %d - %s\n",
|
|
ret, strerror(errno));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
tevent_debug(ev, TEVENT_DEBUG_WARNING,
|
|
"tevent_common_loop_wait() out of events\n");
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
return on failure or (with 0) if all fd events are removed
|
|
*/
|
|
int _tevent_loop_wait(struct tevent_context *ev, const char *location)
|
|
{
|
|
return ev->ops->loop_wait(ev, location);
|
|
}
|
|
|
|
|
|
/*
|
|
re-initialise a tevent context. This leaves you with the same
|
|
event context, but all events are wiped and the structure is
|
|
re-initialised. This is most useful after a fork()
|
|
|
|
zero is returned on success, non-zero on failure
|
|
*/
|
|
int tevent_re_initialise(struct tevent_context *ev)
|
|
{
|
|
tevent_common_context_destructor(ev);
|
|
|
|
return ev->ops->context_init(ev);
|
|
}
|
|
|
|
static void wakeup_pipe_handler(struct tevent_context *ev,
|
|
struct tevent_fd *fde,
|
|
uint16_t flags, void *_private)
|
|
{
|
|
ssize_t ret;
|
|
|
|
char c[16];
|
|
/* its non-blocking, doesn't matter if we read too much */
|
|
do {
|
|
ret = read(fde->fd, c, sizeof(c));
|
|
} while (ret == -1 && errno == EINTR);
|
|
}
|
|
|
|
/*
|
|
* Initialize the wakeup pipe and pipe fde
|
|
*/
|
|
|
|
int tevent_common_wakeup_init(struct tevent_context *ev)
|
|
{
|
|
int ret;
|
|
|
|
if (ev->pipe_fde != NULL) {
|
|
return 0;
|
|
}
|
|
|
|
ret = pipe(ev->pipe_fds);
|
|
if (ret == -1) {
|
|
return errno;
|
|
}
|
|
ev_set_blocking(ev->pipe_fds[0], false);
|
|
ev_set_blocking(ev->pipe_fds[1], false);
|
|
|
|
ev->pipe_fde = tevent_add_fd(ev, ev, ev->pipe_fds[0],
|
|
TEVENT_FD_READ,
|
|
wakeup_pipe_handler, NULL);
|
|
if (ev->pipe_fde == NULL) {
|
|
close(ev->pipe_fds[0]);
|
|
close(ev->pipe_fds[1]);
|
|
return ENOMEM;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int tevent_common_wakeup(struct tevent_context *ev)
|
|
{
|
|
ssize_t ret;
|
|
|
|
if (ev->pipe_fds[1] == -1) {
|
|
return ENOTCONN;
|
|
}
|
|
|
|
do {
|
|
char c = '\0';
|
|
ret = write(ev->pipe_fds[1], &c, 1);
|
|
} while ((ret == -1) && (errno == EINTR));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void tevent_common_wakeup_fini(struct tevent_context *ev)
|
|
{
|
|
if (ev->pipe_fde == NULL) {
|
|
return;
|
|
}
|
|
|
|
TALLOC_FREE(ev->pipe_fde);
|
|
|
|
close(ev->pipe_fds[0]);
|
|
close(ev->pipe_fds[1]);
|
|
}
|