denozord/strongswan-ext
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use a separate interface for loggers.

Browse Source 
The new interface does not allow loggers to unregister themselves from
the bus.  This allows us to use a rwlock_t for them.

The latter also means that loggers can now be called concurrently by
multiple threads.
This commit is contained in:
Tobias Brunner
2012-05-02 14:45:38 +02:00
parent f9f867899a
commit 0e474f9148
17 changed files with 288 additions and 300 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libcharon/bus/bus.c
+103 -192
View File
@@ -1,5 +1,5 @@
/*
* Copyright (C) 2011 Tobias Brunner
* Copyright (C) 2011-2012 Tobias Brunner
* Copyright (C) 2006 Martin Willi
* Hochschule fuer Technik Rapperswil
*
@@ -21,6 +21,7 @@
#include <threading/thread.h>
#include <threading/thread_value.h>
#include <threading/mutex.h>
#include <threading/rwlock.h>
typedef struct private_bus_t private_bus_t;
@@ -34,24 +35,24 @@ struct private_bus_t {
bus_t public;
/**
* List of registered listeners as entry_t's
* List of registered listeners as entry_t.
*/
linked_list_t *listeners;
/**
* List of registered listeners implementing listener_t.log() as entry_t
* List of registered loggers.
*/
linked_list_t *loggers;
/**
* mutex for the list of listeners, recursively
* Mutex for the list of listeners, recursively.
*/
mutex_t *mutex;
/**
* mutex for the list of loggers
* Read-write lock for the list of loggers.
*/
mutex_t *log_mutex;
rwlock_t *log_lock;
/**
* Thread local storage the threads IKE_SA
@@ -76,61 +77,27 @@ struct entry_t {
*/
int calling;
/**
* are we currently logging on this listener
*/
int logging;
/**
* TRUE if this listener is active (we use this for the loggers)
*/
bool enabled;
};
/**
* create a listener entry
*/
static entry_t *entry_create(listener_t *listener)
{
entry_t *this;
INIT(this,
.listener = listener,
.enabled = TRUE,
);
return this;
}
/**
* destroy an entry_t
*/
static void entry_destroy(entry_t *entry)
{
free(entry);
}
METHOD(bus_t, add_listener, void,
private_bus_t *this, listener_t *listener)
{
entry_t *entry = entry_create(listener);
entry_t *entry;
INIT(entry,
.listener = listener,
);
this->mutex->lock(this->mutex);
this->listeners->insert_last(this->listeners, entry);
this->mutex->unlock(this->mutex);
if (listener->log)
{
this->log_mutex->lock(this->log_mutex);
this->loggers->insert_last(this->loggers, entry);
this->log_mutex->unlock(this->log_mutex);
}
}
METHOD(bus_t, remove_listener, void,
private_bus_t *this, listener_t *listener)
{
enumerator_t *enumerator;
entry_t *entry, *found = NULL;
entry_t *entry;
this->mutex->lock(this->mutex);
enumerator = this->listeners->create_enumerator(this->listeners);
@@ -139,33 +106,29 @@ METHOD(bus_t, remove_listener, void,
if (entry->listener == listener)
{
this->listeners->remove_at(this->listeners, enumerator);
found = entry;
free(entry);
break;
}
}
enumerator->destroy(enumerator);
this->mutex->unlock(this->mutex);
if (found)
{
this->log_mutex->lock(this->log_mutex);
this->loggers->remove(this->loggers, found, NULL);
this->log_mutex->unlock(this->log_mutex);
entry_destroy(found);
}
}
typedef struct cleanup_data_t cleanup_data_t;
METHOD(bus_t, add_logger, void,
private_bus_t *this, logger_t *logger)
{
this->log_lock->write_lock(this->log_lock);
this->loggers->insert_last(this->loggers, logger);
this->log_lock->unlock(this->log_lock);
}
/**
* data to remove a listener using thread_cleanup_t handler
*/
struct cleanup_data_t {
/** bus instance */
private_bus_t *this;
/** listener entry */
entry_t *entry;
};
METHOD(bus_t, remove_logger, void,
private_bus_t *this, logger_t *logger)
{
this->log_lock->write_lock(this->log_lock);
this->loggers->remove(this->loggers, logger, NULL);
this->log_lock->unlock(this->log_lock);
}
METHOD(bus_t, set_sa, void,
private_bus_t *this, ike_sa_t *ike_sa)
@@ -198,29 +161,16 @@ typedef struct {
} log_data_t;
/**
* listener->log() invocation as a list remove callback
* logger->log() invocation as a invoke_function callback
*/
static bool log_cb(entry_t *entry, log_data_t *data)
static void log_cb(logger_t *logger, log_data_t *data)
{
va_list args;
if (entry->logging)
{ /* avoid recursive calls */
return FALSE;
}
entry->logging = TRUE;
va_copy(args, data->args);
if (!entry->listener->log(entry->listener, data->group, data->level,
data->thread, data->ike_sa, data->format, args))
{
entry->enabled = FALSE;
va_end(args);
return TRUE;
}
logger->log(logger, data->group, data->level, data->thread, data->ike_sa,
data->format, args);
va_end(args);
entry->logging = FALSE;
return FALSE;
}
METHOD(bus_t, vlog, void,
@@ -236,11 +186,9 @@ METHOD(bus_t, vlog, void,
data.format = format;
va_copy(data.args, args);
this->log_mutex->lock(this->log_mutex);
/* We use the remove() method to invoke all listeners. This is cheap and
* does not require an allocation for this performance critical function. */
this->loggers->remove(this->loggers, &data, (void*)log_cb);
this->log_mutex->unlock(this->log_mutex);
this->log_lock->read_lock(this->log_lock);
this->loggers->invoke_function(this->loggers, (void*)log_cb, &data);
this->log_lock->unlock(this->log_lock);
va_end(data.args);
}
@@ -258,14 +206,11 @@ METHOD(bus_t, log_, void,
/**
* unregister a listener
*/
static void unregister_listener(private_bus_t *this, entry_t *entry,
enumerator_t *enumerator)
static inline void unregister_listener(private_bus_t *this, entry_t *entry,
enumerator_t *enumerator)
{
this->listeners->remove_at(this->listeners, enumerator);
this->log_mutex->lock(this->log_mutex);
this->loggers->remove(this->loggers, entry, NULL);
this->log_mutex->unlock(this->log_mutex);
entry_destroy(entry);
free(entry);
}
METHOD(bus_t, alert, void,
@@ -287,15 +232,12 @@ METHOD(bus_t, alert, void,
{
continue;
}
if (entry->enabled)
{
entry->calling++;
va_start(args, alert);
keep = entry->listener->alert(entry->listener, ike_sa, alert, args);
va_end(args);
entry->calling--;
}
if (!entry->enabled || !keep)
entry->calling++;
va_start(args, alert);
keep = entry->listener->alert(entry->listener, ike_sa, alert, args);
va_end(args);
entry->calling--;
if (!keep)
{
unregister_listener(this, entry, enumerator);
}
@@ -319,13 +261,10 @@ METHOD(bus_t, ike_state_change, void,
{
continue;
}
if (entry->enabled)
{
entry->calling++;
keep = entry->listener->ike_state_change(entry->listener, ike_sa, state);
entry->calling--;
}
if (!entry->enabled || !keep)
entry->calling++;
keep = entry->listener->ike_state_change(entry->listener, ike_sa, state);
entry->calling--;
if (!keep)
{
unregister_listener(this, entry, enumerator);
}
@@ -352,14 +291,11 @@ METHOD(bus_t, child_state_change, void,
{
continue;
}
if (entry->enabled)
{
entry->calling++;
keep = entry->listener->child_state_change(entry->listener, ike_sa,
child_sa, state);
entry->calling--;
}
if (!entry->enabled || !keep)
entry->calling++;
keep = entry->listener->child_state_change(entry->listener, ike_sa,
child_sa, state);
entry->calling--;
if (!keep)
{
unregister_listener(this, entry, enumerator);
}
@@ -386,14 +322,11 @@ METHOD(bus_t, message, void,
{
continue;
}
if (entry->enabled)
{
entry->calling++;
keep = entry->listener->message(entry->listener, ike_sa,
message, incoming, plain);
entry->calling--;
}
if (!entry->enabled || !keep)
entry->calling++;
keep = entry->listener->message(entry->listener, ike_sa,
message, incoming, plain);
entry->calling--;
if (!keep)
{
unregister_listener(this, entry, enumerator);
}
@@ -419,14 +352,11 @@ METHOD(bus_t, ike_keys, void,
{
continue;
}
if (entry->enabled)
{
entry->calling++;
keep = entry->listener->ike_keys(entry->listener, ike_sa, dh, dh_other,
nonce_i, nonce_r, rekey, shared);
entry->calling--;
}
if (!entry->enabled || !keep)
entry->calling++;
keep = entry->listener->ike_keys(entry->listener, ike_sa, dh, dh_other,
nonce_i, nonce_r, rekey, shared);
entry->calling--;
if (!keep)
{
unregister_listener(this, entry, enumerator);
}
@@ -454,14 +384,11 @@ METHOD(bus_t, child_keys, void,
{
continue;
}
if (entry->enabled)
{
entry->calling++;
keep = entry->listener->child_keys(entry->listener, ike_sa,
child_sa, initiator, dh, nonce_i, nonce_r);
entry->calling--;
}
if (!entry->enabled || !keep)
entry->calling++;
keep = entry->listener->child_keys(entry->listener, ike_sa,
child_sa, initiator, dh, nonce_i, nonce_r);
entry->calling--;
if (!keep)
{
unregister_listener(this, entry, enumerator);
}
@@ -488,14 +415,11 @@ METHOD(bus_t, child_updown, void,
{
continue;
}
if (entry->enabled)
{
entry->calling++;
keep = entry->listener->child_updown(entry->listener,
ike_sa, child_sa, up);
entry->calling--;
}
if (!entry->enabled || !keep)
entry->calling++;
keep = entry->listener->child_updown(entry->listener,
ike_sa, child_sa, up);
entry->calling--;
if (!keep)
{
unregister_listener(this, entry, enumerator);
}
@@ -522,14 +446,11 @@ METHOD(bus_t, child_rekey, void,
{
continue;
}
if (entry->enabled)
{
entry->calling++;
keep = entry->listener->child_rekey(entry->listener, ike_sa,
old, new);
entry->calling--;
}
if (!entry->enabled || !keep)
entry->calling++;
keep = entry->listener->child_rekey(entry->listener, ike_sa,
old, new);
entry->calling--;
if (!keep)
{
unregister_listener(this, entry, enumerator);
}
@@ -553,13 +474,10 @@ METHOD(bus_t, ike_updown, void,
{
continue;
}
if (entry->enabled)
{
entry->calling++;
keep = entry->listener->ike_updown(entry->listener, ike_sa, up);
entry->calling--;
}
if (!entry->enabled || !keep)
entry->calling++;
keep = entry->listener->ike_updown(entry->listener, ike_sa, up);
entry->calling--;
if (!keep)
{
unregister_listener(this, entry, enumerator);
}
@@ -597,13 +515,10 @@ METHOD(bus_t, ike_rekey, void,
{
continue;
}
if (entry->enabled)
{
entry->calling++;
keep = entry->listener->ike_rekey(entry->listener, old, new);
entry->calling--;
}
if (!entry->enabled || !keep)
entry->calling++;
keep = entry->listener->ike_rekey(entry->listener, old, new);
entry->calling--;
if (!keep)
{
unregister_listener(this, entry, enumerator);
}
@@ -630,14 +545,11 @@ METHOD(bus_t, authorize, bool,
{
continue;
}
if (entry->enabled)
{
entry->calling++;
keep = entry->listener->authorize(entry->listener, ike_sa,
final, &success);
entry->calling--;
}
if (!entry->enabled || !keep)
entry->calling++;
keep = entry->listener->authorize(entry->listener, ike_sa,
final, &success);
entry->calling--;
if (!keep)
{
unregister_listener(this, entry, enumerator);
}
@@ -670,14 +582,11 @@ METHOD(bus_t, narrow, void,
{
continue;
}
if (entry->enabled)
{
entry->calling++;
keep = entry->listener->narrow(entry->listener, ike_sa, child_sa,
type, local, remote);
entry->calling--;
}
if (!entry->enabled || !keep)
entry->calling++;
keep = entry->listener->narrow(entry->listener, ike_sa, child_sa,
type, local, remote);
entry->calling--;
if (!keep)
{
unregister_listener(this, entry, enumerator);
}
@@ -689,11 +598,11 @@ METHOD(bus_t, narrow, void,
METHOD(bus_t, destroy, void,
private_bus_t *this)
{
this->thread_sa->destroy(this->thread_sa);
this->log_mutex->destroy(this->log_mutex);
this->mutex->destroy(this->mutex);
this->listeners->destroy_function(this->listeners, (void*)entry_destroy);
this->listeners->destroy_function(this->listeners, (void*)free);
this->loggers->destroy(this->loggers);
this->thread_sa->destroy(this->thread_sa);
this->log_lock->destroy(this->log_lock);
this->mutex->destroy(this->mutex);
free(this);
}
@@ -708,6 +617,8 @@ bus_t *bus_create()
.public = {
.add_listener = _add_listener,
.remove_listener = _remove_listener,
.add_logger = _add_logger,
.remove_logger = _remove_logger,
.set_sa = _set_sa,
.get_sa = _get_sa,
.log = _log_,
@@ -729,7 +640,7 @@ bus_t *bus_create()
.listeners = linked_list_create(),
.loggers = linked_list_create(),
.mutex = mutex_create(MUTEX_TYPE_RECURSIVE),
.log_mutex = mutex_create(MUTEX_TYPE_RECURSIVE),
.log_lock = rwlock_create(RWLOCK_TYPE_DEFAULT),
.thread_sa = thread_value_create(NULL),
);
src/libcharon/bus/bus.h
+22 -6
View File
@@ -1,4 +1,5 @@
/*
* Copyright (C) 2012 Tobias Brunner
* Copyright (C) 2006-2009 Martin Willi
* Hochschule fuer Technik Rapperswil
*
@@ -31,6 +32,7 @@ typedef struct bus_t bus_t;
#include <sa/ike_sa.h>
#include <sa/child_sa.h>
#include <processing/jobs/job.h>
#include <bus/listeners/logger.h>
#include <bus/listeners/listener.h>
/* undefine the definitions from libstrongswan */
@@ -118,12 +120,7 @@ enum narrow_hook_t {
/**
* The bus receives events and sends them to all registered listeners.
*
* Calls to bus_t.log() are handled seperately from calls to other event
* functions. This means that listeners have to be aware that calls to
* listener_t.log() can happen concurrently with calls to one of the other
* callbacks. Due to this unregistering from the log() callback is not fully
* in sync with the other callbacks, thus, one of these might be called before
* the listener is finally unregistered.
* Loggers are handled separately.
*/
struct bus_t {
@@ -145,6 +142,25 @@ struct bus_t {
*/
void (*remove_listener) (bus_t *this, listener_t *listener);
/**
* Register a logger with the bus.
*
* The logger is passive; the thread which emitted the event
* processes the logger routine. This routine may be called concurrently
* by multiple threads. Recursive calls are not prevented, so logger that
* may cause recursive calls are responsible to avoid infinite loops.
*
* @param logger logger to register.
*/
void (*add_logger) (bus_t *this, logger_t *logger);
/**
* Unregister a logger from the bus.
*
* @param logger logger to unregister.
*/
void (*remove_logger) (bus_t *this, logger_t *logger);
/**
* Set the IKE_SA the calling thread is using.
*
src/libcharon/bus/listeners/file_logger.c
+7 -8
View File
@@ -1,4 +1,5 @@
/*
* Copyright (C) 2012 Tobias Brunner
* Copyright (C) 2006 Martin Willi
* Hochschule fuer Technik Rapperswil
*
@@ -53,9 +54,9 @@ struct private_file_logger_t {
bool ike_name;
};
METHOD(listener_t, log_, bool,
private_file_logger_t *this, debug_t group, level_t level, int thread,
ike_sa_t* ike_sa, char *format, va_list args)
METHOD(logger_t, log_, void,
private_file_logger_t *this, debug_t group, level_t level, int thread,
ike_sa_t* ike_sa, char *format, va_list args)
{
if (level <= this->levels[group])
{
@@ -112,12 +113,10 @@ METHOD(listener_t, log_, bool,
current = next;
}
}
/* always stay registered */
return TRUE;
}
METHOD(file_logger_t, set_level, void,
private_file_logger_t *this, debug_t group, level_t level)
private_file_logger_t *this, debug_t group, level_t level)
{
if (group < DBG_ANY)
{
@@ -133,7 +132,7 @@ METHOD(file_logger_t, set_level, void,
}
METHOD(file_logger_t, destroy, void,
private_file_logger_t *this)
private_file_logger_t *this)
{
if (this->out != stdout && this->out != stderr)
{
@@ -151,7 +150,7 @@ file_logger_t *file_logger_create(FILE *out, char *time_format, bool ike_name)
INIT(this,
.public = {
.listener = {
.logger = {
.log = _log_,
},
.set_level = _set_level,
src/libcharon/bus/listeners/file_logger.h
+3 -3
View File
@@ -21,7 +21,7 @@
#ifndef FILE_LOGGER_H_
#define FILE_LOGGER_H_
#include <bus/listeners/listener.h>
#include <bus/listeners/logger.h>
typedef struct file_logger_t file_logger_t;
@@ -31,9 +31,9 @@ typedef struct file_logger_t file_logger_t;
struct file_logger_t {
/**
* Implements the listener_t interface.
* Implements the logger_t interface.
*/
listener_t listener;
logger_t logger;
/**
* Set the loglevel for a debug group.
src/libcharon/bus/listeners/listener.h
-27
View File
@@ -30,33 +30,6 @@ typedef struct listener_t listener_t;
*/
struct listener_t {
/**
* Log a debugging message.
*
* The implementing signal function returns TRUE to stay registered
* to the bus, or FALSE to unregister itself.
*
* Calling bus_t.log() inside of a registered listener is possible
* from all listener_t callbacks, but recursive calls from log() itself
* are ignored.
*
* Note that calls to bus_t.log() are handled seperately from calls to
* other functions, thus this callback may be called concurrently with
* some of the others. Because of this unregistering from this callback
* does not happen in sync with the other callbacks, thus, one of the other
* callbacks might be called before the listener is finally unregistered.
*
* @param group kind of the signal (up, down, rekeyed, ...)
* @param level verbosity level of the signal
* @param thread ID of the thread raised this signal
* @param ike_sa IKE_SA associated to the event
* @param format printf() style format string
* @param args vprintf() style va_list argument list
* @return TRUE to stay registered, FALSE to unregister
*/
bool (*log)(listener_t *this, debug_t group, level_t level, int thread,
ike_sa_t *ike_sa, char* format, va_list args);
/**
* Hook called if a critical alert is risen.
*
src/libcharon/bus/listeners/logger.h
+53
View File
@@ -0,0 +1,53 @@
/*
* Copyright (C) 2012 Tobias Brunner
* Hochschule fuer Technik Rapperswil
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
*
* This program 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 General Public License
* for more details.
*/
/**
* @defgroup logger logger
* @{ @ingroup listeners
*/
#ifndef LOGGER_H_
#define LOGGER_H_
typedef struct logger_t logger_t;
#include <bus/bus.h>
/**
* Logger interface, listens for log events on the bus.
*/
struct logger_t {
/**
* Log a debugging message.
*
* @note Calls to bus_t.log() are handled seperately from calls to
* other functions. This callback may be called concurrently by
* multiple threads. Also recurisve calls are not prevented, logger that
* may cause recursive calls are responsible to avoid infinite loops.
*
* @param group kind of the signal (up, down, rekeyed, ...)
* @param level verbosity level of the signal
* @param thread ID of the thread raised this signal
* @param ike_sa IKE_SA associated to the event
* @param format printf() style format string
* @param args vprintf() style argument list
*/
void (*log)(logger_t *this, debug_t group, level_t level, int thread,
ike_sa_t *ike_sa, char* format, va_list args);
};
#endif /** LOGGER_H_ @}*/
src/libcharon/bus/listeners/sys_logger.c
+9 -10
View File
@@ -1,4 +1,5 @@
/*
* Copyright (C) 2012 Tobias Brunner
* Copyright (C) 2006 Martin Willi
* Hochschule fuer Technik Rapperswil
*
@@ -48,9 +49,9 @@ struct private_sys_logger_t {
bool ike_name;
};
METHOD(listener_t, log_, bool,
private_sys_logger_t *this, debug_t group, level_t level, int thread,
ike_sa_t* ike_sa, char *format, va_list args)
METHOD(logger_t, log_, void,
private_sys_logger_t *this, debug_t group, level_t level, int thread,
ike_sa_t* ike_sa, char *format, va_list args)
{
if (level <= this->levels[group])
{
@@ -59,7 +60,7 @@ METHOD(listener_t, log_, bool,
/* write in memory buffer first */
vsnprintf(buffer, sizeof(buffer), format, args);
/* cache group name */
/* cache group name and optional name string */
snprintf(groupstr, sizeof(groupstr), "%N", debug_names, group);
if (this->ike_name && ike_sa)
@@ -76,7 +77,7 @@ METHOD(listener_t, log_, bool,
}
}
/* do a syslog with every line */
/* do a syslog for every line */
while (current)
{
next = strchr(current, '\n');
@@ -89,12 +90,10 @@ METHOD(listener_t, log_, bool,
current = next;
}
}
/* always stay registered */
return TRUE;
}
METHOD(sys_logger_t, set_level, void,
private_sys_logger_t *this, debug_t group, level_t level)
private_sys_logger_t *this, debug_t group, level_t level)
{
if (group < DBG_ANY)
{
@@ -110,7 +109,7 @@ METHOD(sys_logger_t, set_level, void,
}
METHOD(sys_logger_t, destroy, void,
private_sys_logger_t *this)
private_sys_logger_t *this)
{
closelog();
free(this);
@@ -125,7 +124,7 @@ sys_logger_t *sys_logger_create(int facility, bool ike_name)
INIT(this,
.public = {
.listener = {
.logger = {
.log = _log_,
},
.set_level = _set_level,
src/libcharon/bus/listeners/sys_logger.h
+3 -3
View File
@@ -21,7 +21,7 @@
#ifndef SYS_LOGGER_H_
#define SYS_LOGGER_H_
#include <bus/listeners/listener.h>
#include <bus/listeners/logger.h>
typedef struct sys_logger_t sys_logger_t;
@@ -31,9 +31,9 @@ typedef struct sys_logger_t sys_logger_t;
struct sys_logger_t {
/**
* Implements the listener_t interface.
* Implements the logger_t interface.
*/
listener_t listener;
logger_t logger;
/**
* Set the loglevel for a debug group.