/*
* Amanda, The Advanced Maryland Automatic Network Disk Archiver
* Copyright (c) 1999 University of Maryland at College Park
* Copyright (c) 2007-2012 Zmanda, Inc. All Rights Reserved.
* Copyright (c) 2013-2016 Carbonite, Inc. All Rights Reserved.
* All Rights Reserved.
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of U.M. not be used in advertising or
* publicity pertaining to distribution of the software without specific,
* written prior permission. U.M. makes no representations about the
* suitability of this software for any purpose. It is provided "as is"
* without express or implied warranty.
*
* U.M. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL U.M.
* BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Authors: the Amanda Development Team. Its members are listed in a
* file named AUTHORS, in the root directory of this distribution.
*/
/*
* $Id: event.c,v 1.24 2006/06/16 10:55:05 martinea Exp $
*
* Event handler. Serializes different kinds of events to allow for
* a uniform interface, central state storage, and centralized
* interdependency logic.
*
* This is a compatibility wrapper over Glib's GMainLoop. New code should
* use Glib's interface directly.
*
* Each event_handle is associated with a unique GSource, identified by it
* event_source_id.
*/
#include "amanda.h"
#include "conffile.h"
#include "event.h"
#include "glib-util.h"
/* TODO: use mem chunks to allocate event_handles */
/* TODO: lock stuff for threading */
/* Write a debugging message if the config variable debug_event
* is greater than or equal to i */
#define event_debug(i, ...) do { \
if ((i) <= debug_event) { \
dbprintf(__VA_ARGS__); \
} \
} while (0)
/*
* The opaque handle passed back to the caller. This is typedefed to
* event_handle_t in our header file.
*/
struct event_handle {
event_fn_t fn; /* function to call when this fires */
void *arg; /* argument to pass to previous function */
event_type_t type; /* type of event */
event_id_t data; /* type data */
GSource *source; /* Glib event source, if one exists */
guint source_id; /* ID of the glib event source */
gboolean has_fired; /* for use by event_wait() */
gboolean is_dead; /* should this event be deleted? */
};
/* A list of all extant event_handle objects, used for searching for particular
* events and for deleting dead events */
GSList *all_events = NULL;
#if (GLIB_MAJOR_VERSION > 2 || (GLIB_MAJOR_VERSION == 2 && GLIB_MINOR_VERSION >= 31))
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#endif
GStaticMutex event_mutex = G_STATIC_MUTEX_INIT;
#if (GLIB_MAJOR_VERSION > 2 || (GLIB_MAJOR_VERSION == 2 && GLIB_MINOR_VERSION >= 31))
# pragma GCC diagnostic pop
#endif
/* should event_loop_run stop? */
gboolean stop = FALSE;
gboolean global_return_when_empty = TRUE;
/*
* Utility functions
*/
static const char *event_type2str(event_type_t type);
static gboolean any_mainloop_events(void);
/* "Fire" an event handle, by calling its callback function */
#define fire(eh) do { \
event_debug(1, "firing %p: %s/%jd\n", eh, event_type2str((eh)->type), (eh)->data); \
if (*(eh)->fn) { (*(eh)->fn)((eh)->arg); } \
(eh)->has_fired = TRUE; \
} while(0)
/* Adapt a Glib callback to an event_handle_t callback; assumes that the
* user_ptr for the Glib callback is a pointer to the event_handle_t. */
static gboolean
event_handle_callback(
gpointer user_ptr)
{
event_handle_t *hdl = (event_handle_t *)user_ptr;
/* if the handle is dead, then don't fire the callback; this means that
* we're in the process of freeing the event */
if (!hdl->is_dead) {
fire(hdl);
}
/* don't ever let GMainLoop destroy GSources */
return TRUE;
}
/*
* Public functions
* DEPRECATED because not safe in multi-thread, callback can be called before event_register return
*/
/*
event_handle_t *
event_register(
event_id_t data,
event_type_t type,
event_fn_t fn,
void *arg)
{
event_handle_t *handle;
handle = event_create(data, type, fn, arg);
event_activate(handle);
return handle;
}
*/
event_handle_t *
event_create(
event_id_t data,
event_type_t type,
event_fn_t fn,
void *arg)
{
event_handle_t *handle;
g_static_mutex_lock(&event_mutex);
/* sanity-checking */
if ((type == EV_READFD) || (type == EV_WRITEFD)) {
/* make sure we aren't given a high fd that will overflow a fd_set */
if (data >= (int)FD_SETSIZE) {
error(_("event_create: Invalid file descriptor %jd"), data);
/*NOTREACHED*/
}
} else if (type == EV_TIME) {
if (data < 0) {
error(_("event_create: interval for EV_TIME must be greater than 0; got %jd"), data);
}
}
handle = g_new0(event_handle_t, 1);
handle->fn = fn;
handle->arg = arg;
handle->type = type;
handle->data = data;
handle->is_dead = FALSE;
event_debug(1, _("event: register: %p->data=%jd, type=%s\n"),
handle, handle->data, event_type2str(handle->type));
g_static_mutex_unlock(&event_mutex);
return handle;
}
void
event_activate(
event_handle_t *handle)
{
GIOCondition cond;
assert(handle != NULL);
g_static_mutex_lock(&event_mutex);
/* add to the list of events */
all_events = g_slist_prepend(all_events, (gpointer)handle);
/* and set up the GSource for this event */
switch (handle->type) {
case EV_READFD:
case EV_WRITEFD:
/* create a new source */
if (handle->type == EV_READFD) {
cond = G_IO_IN | G_IO_HUP | G_IO_ERR;
} else {
cond = G_IO_OUT | G_IO_ERR;
}
handle->source = new_fdsource(handle->data, cond);
/* attach it to the default GMainLoop */
g_source_attach(handle->source, NULL);
handle->source_id = g_source_get_id(handle->source);
/* And set its callbacks */
g_source_set_callback(handle->source, event_handle_callback,
(gpointer)handle, NULL);
/* drop our reference to it, so when it's detached, it will be
* destroyed. */
g_source_unref(handle->source);
break;
case EV_TIME:
/* Glib provides a nice shortcut for timeouts. The *1000 converts
* seconds to milliseconds. */
handle->source_id = g_timeout_add(handle->data * 1000, event_handle_callback,
(gpointer)handle);
/* But it doesn't give us the source directly.. */
handle->source = g_main_context_find_source_by_id(NULL, handle->source_id);
/* EV_TIME must always be handled after EV_READ */
g_source_set_priority(handle->source, 10);
break;
case EV_WAIT:
/* nothing to do -- these are handled independently of GMainLoop */
break;
default:
error(_("Unknown event type %s"), event_type2str(handle->type));
}
g_static_mutex_unlock(&event_mutex);
return;
}
/*
* Mark an event to be released. Because we may be traversing the queue
* when this is called, we must wait until later to actually remove
* the event.
*/
void
event_release(
event_handle_t *handle)
{
assert(handle != NULL);
g_static_mutex_lock(&event_mutex);
event_debug(1, _("event: release (mark): %p data=%jd, type=%s\n"),
handle, handle->data,
event_type2str(handle->type));
assert(!handle->is_dead);
/* Mark it as dead and leave it for the event_loop to remove */
handle->is_dead = TRUE;
if (global_return_when_empty && !any_mainloop_events()) {
g_main_loop_quit(default_main_loop());
}
g_static_mutex_unlock(&event_mutex);
}
/*
* Fire all EV_WAIT events waiting on the specified id.
*/
int
event_wakeup(
event_id_t id)
{
GSList *iter;
GSList *tofire = NULL;
int nwaken = 0;
g_static_mutex_lock(&event_mutex);
event_debug(1, _("event: wakeup: enter (%jd)\n"), id);
/* search for any and all matching events, and record them. This way
* we have determined the whole list of events we'll be firing *before*
* we fire any of them. */
for (iter = all_events; iter != NULL; iter = g_slist_next(iter)) {
event_handle_t *eh = (event_handle_t *)iter->data;
if (eh->type == EV_WAIT && eh->data == id && !eh->is_dead) {
tofire = g_slist_append(tofire, (gpointer)eh);
}
}
/* fire them */
for (iter = tofire; iter != NULL; iter = g_slist_next(iter)) {
event_handle_t *eh = (event_handle_t *)iter->data;
if (eh->type == EV_WAIT && eh->data == id && !eh->is_dead) {
event_debug(1, _("A: event: wakeup triggering: %p id=%jd\n"), eh, id);
/* The lcok must be release before running the event */
g_static_mutex_unlock(&event_mutex);
fire(eh);
g_static_mutex_lock(&event_mutex);
nwaken++;
}
}
/* and free the temporary list */
g_slist_free(tofire);
g_static_mutex_unlock(&event_mutex);
return (nwaken);
}
/*
* The event loop.
*/
static void event_loop_wait (event_handle_t *, const int, gboolean return_when_empty);
void
event_loop(
int nonblock)
{
event_loop_wait(NULL, nonblock, TRUE);
}
void
event_loop_run(
void)
{
stop = FALSE;
event_loop_wait(NULL, 0, FALSE);
}
void
event_loop_quit(
void)
{
stop = TRUE;
}
void
event_wait(
event_handle_t *eh)
{
event_loop_wait(eh, 0, TRUE);
}
/* Flush out any dead events in all_events. Be careful that this
* isn't called while someone is iterating over all_events.
*
* @param wait_eh: the event handle we're waiting on, which shouldn't
* be flushed.
*/
static void
flush_dead_events(event_handle_t *wait_eh)
{
GSList *iter, *next;
for (iter = all_events; iter != NULL; iter = next) {
event_handle_t *hdl = (event_handle_t *)iter->data;
next = g_slist_next(iter);
/* (handle the case when wait_eh is dead by simply not deleting
* it; the next run of event_loop will take care of it) */
if (hdl->is_dead && hdl != wait_eh) {
all_events = g_slist_delete_link(all_events, iter);
if (hdl->source) g_source_destroy(hdl->source);
amfree(hdl);
}
}
}
/* Return TRUE if we have any events outstanding that can be dispatched
* by GMainLoop. Recall EV_WAIT events appear in all_events, but are
* not dispatched by GMainLoop. */
static gboolean
any_mainloop_events(void)
{
GSList *iter;
gboolean ret = FALSE;
for (iter = all_events; iter != NULL; iter = g_slist_next(iter)) {
event_handle_t *hdl = (event_handle_t *)iter->data;
event_debug(2, _("list %p: %s %s/%jd\n"), hdl, hdl->is_dead?"dead":"alive", event_type2str((hdl)->type), (hdl)->data);
if (hdl->type != EV_WAIT && !hdl->is_dead)
ret = TRUE;
}
return ret;
}
static void
event_loop_wait(
event_handle_t *wait_eh,
int nonblock,
gboolean return_when_empty)
{
global_return_when_empty = return_when_empty;
g_static_mutex_lock(&event_mutex);
event_debug(1, _("event: loop: enter: nonblockg=%d, eh=%p\n"), nonblock, wait_eh);
/* If we're waiting for a specific event, then reset its has_fired flag */
if (wait_eh) {
wait_eh->has_fired = FALSE;
}
/* Keep looping until there are no events, or until wait_eh has fired */
while (1) {
/* clean up first, so we don't accidentally check a dead source */
flush_dead_events(wait_eh);
/* if there's nothing to wait for, then don't block, but run an
* iteration so that any other users of GMainLoop will get a chance
* to run. */
if (return_when_empty && !any_mainloop_events())
break;
/* Do an iteration */
/* Relese the lock before running an iteration */
g_static_mutex_unlock(&event_mutex);
g_main_context_iteration(NULL, !nonblock);
g_static_mutex_lock(&event_mutex);
/* stop if we're told to */
if (!return_when_empty && stop)
break;
/* If the event we've been waiting for has fired or been released, as
* appropriate, we're done. See the comments for event_wait in event.h
* for the skinny on this weird expression. */
if (wait_eh && ((wait_eh->type == EV_WAIT && wait_eh->is_dead)
|| (wait_eh->type != EV_WAIT && wait_eh->has_fired)))
break;
/* Don't loop if we're not blocking */
if (nonblock)
break;
}
/* extra cleanup, to keep all_events short, and to delete wait_eh if it
* has been released. */
flush_dead_events(NULL);
g_static_mutex_unlock(&event_mutex);
}
GMainLoop *
default_main_loop(void)
{
static GMainLoop *loop = NULL;
if (!loop)
loop = g_main_loop_new(NULL, TRUE);
return loop;
}
/*
* Convert an event type into a string
*/
static const char *
event_type2str(
event_type_t type)
{
static const struct {
event_type_t type;
const char name[12];
} event_types[] = {
#define X(s) { s, stringize(s) }
X(EV_READFD),
X(EV_WRITEFD),
X(EV_TIME),
X(EV_WAIT),
#undef X
};
size_t i;
for (i = 0; i < G_N_ELEMENTS(event_types); i++)
if (type == event_types[i].type)
return (event_types[i].name);
return (_("BOGUS EVENT TYPE"));
}
/*
* FDSource -- a source for a file descriptor
*
* We could use Glib's GIOChannel for this, but it adds some buffering
* and Unicode functionality that we really don't want. The custom GSource
* is simple enough anyway, and the Glib documentation describes it in prose.
*/
typedef struct FDSource {
GSource source; /* must be the first element in the struct */
GPollFD pollfd; /* Our file descriptor */
} FDSource;
static gboolean
fdsource_prepare(
GSource *source G_GNUC_UNUSED,
gint *timeout_)
{
*timeout_ = -1; /* block forever, as far as we're concerned */
return FALSE;
}
static gboolean
fdsource_check(
GSource *source)
{
FDSource *fds = (FDSource *)source;
/* we need to be dispatched if any interesting events have been received by the FD */
return fds->pollfd.events & fds->pollfd.revents;
}
static gboolean
fdsource_dispatch(
GSource *source G_GNUC_UNUSED,
GSourceFunc callback,
gpointer user_data)
{
if (callback)
return callback(user_data);
/* Don't automatically detach the event source if there's no callback. */
return TRUE;
}
GSource *
new_fdsource(gint fd, GIOCondition events)
{
static GSourceFuncs *fdsource_funcs = NULL;
GSource *src;
FDSource *fds;
/* initialize these here to avoid a compiler warning */
if (!fdsource_funcs) {
fdsource_funcs = g_new0(GSourceFuncs, 1);
fdsource_funcs->prepare = fdsource_prepare;
fdsource_funcs->check = fdsource_check;
fdsource_funcs->dispatch = fdsource_dispatch;
}
src = g_source_new(fdsource_funcs, sizeof(FDSource));
fds = (FDSource *)src;
fds->pollfd.fd = fd;
fds->pollfd.events = events;
g_source_add_poll(src, &fds->pollfd);
return src;
}
/*
* ChildWatchSource -- a source for a file descriptor
*
* Newer versions of glib provide equivalent functionality; consider
* optionally using that, protected by a GLIB_CHECK_VERSION condition.
*/
/* Versions before glib-2.4.0 didn't include a child watch source, and versions
* before 2.6.0 used unreliable signals. On these versions, we implement
* a "dumb" version of our own invention. This is dumb in the sense that it
* doesn't use SIGCHLD to detect a dead child, preferring to just poll at
* exponentially increasing interals. Writing a smarter implementation runs into
* some tricky race conditions and extra machinery. Since there are few, if any,
* users of a glib version this old, such machinery wouldn't get much testing.
*
* FreeBSD users have also reported problems with the glib child watch source,
* so we use the dumb version on FreeBSD, too.
*/
#if (defined(__FreeBSD__) || GLIB_MAJOR_VERSION < 2 || (GLIB_MAJOR_VERSION == 2 && GLIB_MINOR_VERSION < 6))
typedef struct ChildWatchSource {
GSource source; /* must be the first element in the struct */
pid_t pid;
gint dead;
gint status;
gint timeout;
} ChildWatchSource;
/* this corresponds to rapid checks for about 10 seconds, after which the
* waitpid() check occurs every 2 seconds. */
#define CWS_BASE_TIMEOUT 20
#define CWS_MULT_TIMEOUT 1.1
#define CWS_MAX_TIMEOUT 2000
static gboolean
child_watch_source_prepare(
GSource *source,
gint *timeout_)
{
ChildWatchSource *cws = (ChildWatchSource *)source;
*timeout_ = cws->timeout;
cws->timeout *= CWS_MULT_TIMEOUT;
if (cws->timeout > CWS_MAX_TIMEOUT) cws->timeout = CWS_MAX_TIMEOUT;
return FALSE;
}
static gboolean
child_watch_source_check(
GSource *source)
{
ChildWatchSource *cws = (ChildWatchSource *)source;
/* is it dead? */
if (!cws->dead && waitpid(cws->pid, &cws->status, WNOHANG) > 0) {
cws->dead = TRUE;
}
return cws->dead;
}
static gboolean
child_watch_source_dispatch(
GSource *source G_GNUC_UNUSED,
GSourceFunc callback,
gpointer user_data)
{
ChildWatchSource *cws = (ChildWatchSource *)source;
/* this shouldn't happen, but just in case */
if (cws->dead) {
if (!callback) {
g_warning("child %jd died before callback was registered", (uintmax_t)cws->pid);
return FALSE;
}
((ChildWatchFunc)callback)(cws->pid, cws->status, user_data);
/* Un-queue this source unconditionally -- the child can't die twice */
return FALSE;
}
return TRUE;
}
GSource *
new_child_watch_source(pid_t pid)
{
static GSourceFuncs *child_watch_source_funcs = NULL;
GSource *src;
ChildWatchSource *cws;
/* initialize these here to avoid a compiler warning */
if (!child_watch_source_funcs) {
child_watch_source_funcs = g_new0(GSourceFuncs, 1);
child_watch_source_funcs->prepare = child_watch_source_prepare;
child_watch_source_funcs->check = child_watch_source_check;
child_watch_source_funcs->dispatch = child_watch_source_dispatch;
}
src = g_source_new(child_watch_source_funcs, sizeof(ChildWatchSource));
cws = (ChildWatchSource *)src;
cws->pid = pid;
cws->dead = FALSE;
cws->timeout = CWS_BASE_TIMEOUT;
return src;
}
#else
/* In more recent versions of glib, we just use the built-in glib source */
GSource *
new_child_watch_source(pid_t pid)
{
return g_child_watch_source_new(pid);
}
#endif