#include <stdint.h>
#include <daemon.h>
-#include <threading.h>
+#include <threading/mutex.h>
ENUM(debug_names, DBG_DMN, DBG_LIB,
"DMN",
#include <daemon.h>
#include <utils/linked_list.h>
-#include <threading.h>
+#include <threading/rwlock.h>
typedef struct private_backend_manager_t private_backend_manager_t;
#include <daemon.h>
-#include <threading.h>
+#include <threading/mutex.h>
#include <utils/linked_list.h>
#include <utils/identification.h>
#include "credential_manager.h"
#include <daemon.h>
-#include <threading.h>
+#include <threading/rwlock.h>
#include <utils/linked_list.h>
#include <credentials/sets/cert_cache.h>
#include <credentials/sets/auth_cfg_wrapper.h>
{
auth->add(auth, AUTH_RULE_CA_CERT, issuer->get_ref(issuer));
DBG1(DBG_CFG, " using trusted ca certificate \"%Y\"",
- issuer->get_subject(issuer));
+ issuer->get_subject(issuer));
trusted = TRUE;
}
else
#include <sched.h>
#include <daemon.h>
-#include <threading.h>
+#include <threading/rwlock.h>
#include <utils/linked_list.h>
/** cache size, a power of 2 for fast modulo */
#include <daemon.h>
#include <network/socket.h>
#include <processing/jobs/callback_job.h>
-#include <threading.h>
+#include <threading/mutex.h>
typedef struct private_sender_t private_sender_t;
#include <daemon.h>
#include <utils/host.h>
#include <utils/linked_list.h>
-#include <threading.h>
+#include <threading/mutex.h>
/**
* Default RADIUS server port, when not configured
#include <daemon.h>
#include <utils/linked_list.h>
-#include <threading.h>
+#include <threading/mutex.h>
typedef struct private_eap_sim_file_triplets_t private_eap_sim_file_triplets_t;
#include "kernel_klips_ipsec.h"
#include <daemon.h>
-#include <threading.h>
+#include <threading/mutex.h>
#include <processing/jobs/callback_job.h>
#include <processing/jobs/acquire_job.h>
#include <processing/jobs/rekey_child_sa_job.h>
#include "kernel_netlink_shared.h"
#include <daemon.h>
-#include <threading.h>
+#include <threading/mutex.h>
#include <utils/hashtable.h>
#include <processing/jobs/callback_job.h>
#include <processing/jobs/acquire_job.h>
#include "kernel_netlink_shared.h"
#include <daemon.h>
-#include <threading.h>
+#include <threading/mutex.h>
#include <utils/linked_list.h>
#include <processing/jobs/callback_job.h>
#include <processing/jobs/roam_job.h>
#include "kernel_netlink_shared.h"
#include <daemon.h>
-#include <threading.h>
+#include <threading/mutex.h>
typedef struct private_netlink_socket_t private_netlink_socket_t;
#include <daemon.h>
#include <utils/host.h>
-#include <threading.h>
+#include <threading/mutex.h>
#include <processing/jobs/callback_job.h>
#include <processing/jobs/acquire_job.h>
#include <processing/jobs/migrate_job.h>
#include <daemon.h>
#include <utils/host.h>
-#include <threading.h>
+#include <threading/mutex.h>
#include <utils/linked_list.h>
#include <processing/jobs/callback_job.h>
#include <processing/jobs/roam_job.h>
#include <daemon.h>
#include <processing/jobs/callback_job.h>
-#include <threading.h>
+#include <threading/mutex.h>
typedef struct private_load_tester_plugin_t private_load_tester_plugin_t;
#include <unistd.h>
#include <daemon.h>
-#include <threading.h>
+#include <threading/rwlock.h>
#include <credentials/certificates/x509.h>
typedef struct private_nm_creds_t private_nm_creds_t;
#include <unistd.h>
#include <daemon.h>
-#include <threading.h>
+#include <threading/mutex.h>
typedef struct private_resolve_handler_t private_resolve_handler_t;
#include <daemon.h>
#include <utils/linked_list.h>
#include <utils/hashtable.h>
-#include <threading.h>
+#include <threading/mutex.h>
#define POOL_LIMIT (sizeof(uintptr_t)*8)
#include "stroke_ca.h"
#include "stroke_cred.h"
-#include <threading.h>
+#include <threading/rwlock.h>
#include <utils/linked_list.h>
#include <crypto/hashers/hasher.h>
#include "stroke_config.h"
#include <daemon.h>
-#include <threading.h>
+#include <threading/mutex.h>
#include <utils/lexparser.h>
typedef struct private_stroke_config_t private_stroke_config_t;
#include <credentials/certificates/ac.h>
#include <utils/linked_list.h>
#include <utils/lexparser.h>
-#include <threading.h>
+#include <threading/rwlock.h>
#include <daemon.h>
/* configuration directories and files */
#include <processing/jobs/callback_job.h>
#include <daemon.h>
-#include <threading.h> /* for Mac OS X compatible accept */
+#include <threading/mutex.h> /* for Mac OS X compatible accept */
#include "stroke_config.h"
#include "stroke_control.h"
*/
#include <library.h>
-#include <threading.h>
+#include <threading/mutex.h>
#include <unistd.h>
#include <sched.h>
#include <pthread.h>
#include <daemon.h>
-#include <threading.h>
+#include <threading/mutex.h>
typedef struct private_callback_job_t private_callback_job_t;
#include "processor.h"
#include <daemon.h>
-#include <threading.h>
+#include <threading/mutex.h>
#include <utils/linked_list.h>
#include <daemon.h>
#include <processing/processor.h>
#include <processing/jobs/callback_job.h>
-#include <threading.h>
+#include <threading/mutex.h>
/* the initial size of the heap */
#define HEAP_SIZE_DEFAULT 64
#include "eap_manager.h"
#include <utils/linked_list.h>
-#include <threading.h>
+#include <threading/rwlock.h>
typedef struct private_eap_manager_t private_eap_manager_t;
typedef struct eap_entry_t eap_entry_t;
#include <math.h>
#include <daemon.h>
-#include <threading.h>
+#include <threading/mutex.h>
#include <utils/linked_list.h>
#include <crypto/hashers/hasher.h>
#include <daemon.h>
#include <sa/ike_sa_id.h>
#include <bus/bus.h>
-#include <threading.h>
+#include <threading/mutex.h>
+#include <threading/rwlock.h>
#include <utils/linked_list.h>
#include <crypto/hashers/hasher.h>
#include "mediation_manager.h"
#include <daemon.h>
-#include <threading.h>
+#include <threading/mutex.h>
#include <utils/linked_list.h>
#include <processing/jobs/mediation_job.h>
#include "trap_manager.h"
#include <daemon.h>
-#include <threading.h>
+#include <threading/rwlock.h>
#include <utils/linked_list.h>
#include <unistd.h>
#include <debug.h>
-#include <threading.h>
+#include <threading/mutex.h>
#include <utils/linked_list.h>
#include <utils/hashtable.h>
database/database.h database/database_factory.h database/database_factory.c \
fetcher/fetcher.h fetcher/fetcher_manager.h fetcher/fetcher_manager.c \
selectors/traffic_selector.c selectors/traffic_selector.h \
-threading.h \
threading/mutex.h threading/mutex.c \
threading/condvar.h threading/condvar.c \
threading/rwlock.h threading/rwlock.c \
#include <debug.h>
#include <utils/linked_list.h>
-#include <threading.h>
+#include <threading/rwlock.h>
typedef struct private_attribute_manager_t private_attribute_manager_t;
#include <debug.h>
#include <utils/linked_list.h>
-#include <threading.h>
+#include <threading/rwlock.h>
#include <credentials/certificates/x509.h>
ENUM(credential_type_names, CRED_PRIVATE_KEY, CRED_CERTIFICATE,
#include <utils/linked_list.h>
#include <utils/hashtable.h>
-#include <threading.h>
+#include <threading/rwlock.h>
typedef struct private_key_encoding_t private_key_encoding_t;
#include "crypto_factory.h"
#include <debug.h>
-#include <threading.h>
+#include <threading/rwlock.h>
#include <utils/linked_list.h>
#include <crypto/crypto_tester.h>
#include "database_factory.h"
#include <utils/linked_list.h>
-#include <threading.h>
+#include <threading/mutex.h>
typedef struct private_database_factory_t private_database_factory_t;
#include "fetcher_manager.h"
#include <debug.h>
-#include <threading.h>
+#include <threading/rwlock.h>
#include <utils/linked_list.h>
typedef struct private_fetcher_manager_t private_fetcher_manager_t;
#include <library.h>
#include <debug.h>
-#include <threading.h>
+#include <threading/mutex.h>
#include <errno.h>
#include <gcrypt.h>
#include "mysql_database.h"
#include <debug.h>
-#include <threading.h>
+#include <threading/mutex.h>
#include <utils/linked_list.h>
/* Older mysql.h headers do not define it, but we need it. It is not returned
#include "openssl_plugin.h"
#include <library.h>
-#include <threading.h>
+#include <threading/mutex.h>
#include "openssl_util.h"
#include "openssl_crypter.h"
#include "openssl_hasher.h"
#include <unistd.h>
#include <library.h>
#include <debug.h>
-#include <threading.h>
+#include <threading/mutex.h>
typedef struct private_sqlite_database_t private_sqlite_database_t;
+++ /dev/null
-/*
- * Copyright (C) 2008-2009 Tobias Brunner
- * Copyright (C) 2008 Martin Willi
- * 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 threading threading
- * @{ @ingroup libstrongswan
- */
-
-#ifndef THREADING_H_
-#define THREADING_H_
-
-typedef struct mutex_t mutex_t;
-typedef struct condvar_t condvar_t;
-typedef struct rwlock_t rwlock_t;
-typedef enum mutex_type_t mutex_type_t;
-typedef enum condvar_type_t condvar_type_t;
-typedef enum rwlock_type_t rwlock_type_t;
-
-#include <library.h>
-
-#ifdef __APPLE__
-/* on Mac OS X 10.5 several system calls we use are no cancellation points.
- * fortunately, select isn't one of them, so we wrap some of the others with
- * calls to select(2).
- */
-#include <sys/socket.h>
-#include <sys/select.h>
-
-#define WRAP_WITH_SELECT(func, socket, ...)\
- fd_set rfds; FD_ZERO(&rfds); FD_SET(socket, &rfds);\
- if (select(socket + 1, &rfds, NULL, NULL, NULL) <= 0) { return -1; }\
- return func(socket, __VA_ARGS__)
-
-static inline int cancellable_accept(int socket, struct sockaddr *address,
- socklen_t *address_len)
-{
- WRAP_WITH_SELECT(accept, socket, address, address_len);
-}
-#define accept cancellable_accept
-static inline int cancellable_recvfrom(int socket, void *buffer, size_t length,
- int flags, struct sockaddr *address, socklen_t *address_len)
-{
- WRAP_WITH_SELECT(recvfrom, socket, buffer, length, flags, address, address_len);
-}
-#define recvfrom cancellable_recvfrom
-#endif /* __APPLE__ */
-
-/**
- * Type of mutex.
- */
-enum mutex_type_t {
- /** default mutex */
- MUTEX_TYPE_DEFAULT = 0,
- /** allow recursive locking of the mutex */
- MUTEX_TYPE_RECURSIVE = 1,
-};
-
-/**
- * Type of condvar.
- */
-enum condvar_type_t {
- /** default condvar */
- CONDVAR_TYPE_DEFAULT = 0,
-};
-
-/**
- * Type of read-write lock.
- */
-enum rwlock_type_t {
- /** default condvar */
- RWLOCK_TYPE_DEFAULT = 0,
-};
-
-/**
- * Mutex wrapper implements simple, portable and advanced mutex functions.
- */
-struct mutex_t {
-
- /**
- * Acquire the lock to the mutex.
- */
- void (*lock)(mutex_t *this);
-
- /**
- * Release the lock on the mutex.
- */
- void (*unlock)(mutex_t *this);
-
- /**
- * Destroy a mutex instance.
- */
- void (*destroy)(mutex_t *this);
-};
-
-/**
- * Condvar wrapper to use in conjunction with mutex_t.
- */
-struct condvar_t {
-
- /**
- * Wait on a condvar until it gets signalized.
- *
- * @param mutex mutex to release while waiting
- */
- void (*wait)(condvar_t *this, mutex_t *mutex);
-
- /**
- * Wait on a condvar until it gets signalized, or times out.
- *
- * @param mutex mutex to release while waiting
- * @param timeout timeout im ms
- * @return TRUE if timed out, FALSE otherwise
- */
- bool (*timed_wait)(condvar_t *this, mutex_t *mutex, u_int timeout);
-
- /**
- * Wait on a condvar until it gets signalized, or times out.
- *
- * The passed timeval should be calculated based on the time_monotonic()
- * function.
- *
- * @param mutex mutex to release while waiting
- * @param tv absolute time until timeout
- * @return TRUE if timed out, FALSE otherwise
- */
- bool (*timed_wait_abs)(condvar_t *this, mutex_t *mutex, timeval_t tv);
-
- /**
- * Wake up a single thread in a condvar.
- */
- void (*signal)(condvar_t *this);
-
- /**
- * Wake up all threads in a condvar.
- */
- void (*broadcast)(condvar_t *this);
-
- /**
- * Destroy a condvar and free its resources.
- */
- void (*destroy)(condvar_t *this);
-};
-
-/**
- * Read-Write lock wrapper.
- */
-struct rwlock_t {
-
- /**
- * Acquire the read lock.
- */
- void (*read_lock)(rwlock_t *this);
-
- /**
- * Acquire the write lock.
- */
- void (*write_lock)(rwlock_t *this);
-
- /**
- * Try to acquire the write lock.
- *
- * Never blocks, but returns FALSE if the lock was already occupied.
- *
- * @return TRUE if lock acquired
- */
- bool (*try_write_lock)(rwlock_t *this);
-
- /**
- * Release any acquired lock.
- */
- void (*unlock)(rwlock_t *this);
-
- /**
- * Destroy the read-write lock.
- */
- void (*destroy)(rwlock_t *this);
-};
-
-/**
- * Create a mutex instance.
- *
- * @param type type of mutex to create
- * @return unlocked mutex instance
- */
-mutex_t *mutex_create(mutex_type_t type);
-
-/**
- * Create a condvar instance.
- *
- * @param type type of condvar to create
- * @return condvar instance
- */
-condvar_t *condvar_create(condvar_type_t type);
-
-/**
- * Create a read-write lock instance.
- *
- * @param type type of rwlock to create
- * @return unlocked rwlock instance
- */
-rwlock_t *rwlock_create(rwlock_type_t type);
-
-#endif /** THREADING_H_ @}*/
#include <time.h>
#include <errno.h>
-#include <threading.h>
#include <library.h>
#include <debug.h>
#include "condvar.h"
#include "mutex.h"
+typedef struct private_condvar_t private_condvar_t;
+
+/**
+ * private data of condvar
+ */
+struct private_condvar_t {
+
+ /**
+ * public functions
+ */
+ condvar_t public;
+
+ /**
+ * wrapped pthread condvar
+ */
+ pthread_cond_t condvar;
+};
+
/**
* Implementation of condvar_t.wait.
*/
/*
- * Copyright (C) 2008 Tobias Brunner
+ * Copyright (C) 2008-2009 Tobias Brunner
* Copyright (C) 2008 Martin Willi
* Hochschule fuer Technik Rapperswil
*
* for more details.
*/
+/**
+ * @defgroup condvar condvar
+ * @{ @ingroup threading
+ */
+
#ifndef THREADING_CONDVAR_H_
#define THREADING_CONDVAR_H_
-typedef struct private_condvar_t private_condvar_t;
+typedef struct condvar_t condvar_t;
+typedef enum condvar_type_t condvar_type_t;
+
+#include "mutex.h"
+
+/**
+ * Type of condvar.
+ */
+enum condvar_type_t {
+ /** default condvar */
+ CONDVAR_TYPE_DEFAULT = 0,
+};
/**
- * private data of condvar
+ * Condvar wrapper to use in conjunction with mutex_t.
*/
-struct private_condvar_t {
+struct condvar_t {
+
+ /**
+ * Wait on a condvar until it gets signalized.
+ *
+ * @param mutex mutex to release while waiting
+ */
+ void (*wait)(condvar_t *this, mutex_t *mutex);
+
+ /**
+ * Wait on a condvar until it gets signalized, or times out.
+ *
+ * @param mutex mutex to release while waiting
+ * @param timeout timeout im ms
+ * @return TRUE if timed out, FALSE otherwise
+ */
+ bool (*timed_wait)(condvar_t *this, mutex_t *mutex, u_int timeout);
+
+ /**
+ * Wait on a condvar until it gets signalized, or times out.
+ *
+ * The passed timeval should be calculated based on the time_monotonic()
+ * function.
+ *
+ * @param mutex mutex to release while waiting
+ * @param tv absolute time until timeout
+ * @return TRUE if timed out, FALSE otherwise
+ */
+ bool (*timed_wait_abs)(condvar_t *this, mutex_t *mutex, timeval_t tv);
+
+ /**
+ * Wake up a single thread in a condvar.
+ */
+ void (*signal)(condvar_t *this);
/**
- * public functions
+ * Wake up all threads in a condvar.
*/
- condvar_t public;
+ void (*broadcast)(condvar_t *this);
/**
- * wrapped pthread condvar
+ * Destroy a condvar and free its resources.
*/
- pthread_cond_t condvar;
+ void (*destroy)(condvar_t *this);
};
-#endif /* THREADING_CONDVAR_H_ */
+/**
+ * Create a condvar instance.
+ *
+ * @param type type of condvar to create
+ * @return condvar instance
+ */
+condvar_t *condvar_create(condvar_type_t type);
+
+#endif /** THREADING_CONDVAR_H_ @} */
#define _GNU_SOURCE
#include <pthread.h>
-#include <threading.h>
#include <library.h>
#include <debug.h>
#include "mutex.h"
#include "lock_profiler.h"
+typedef struct private_mutex_t private_mutex_t;
+typedef struct private_r_mutex_t private_r_mutex_t;
+
+/**
+ * private data of mutex
+ */
+struct private_mutex_t {
+
+ /**
+ * public functions
+ */
+ mutex_t public;
+
+ /**
+ * wrapped pthread mutex
+ */
+ pthread_mutex_t mutex;
+
+ /**
+ * is this a recursiv emutex, implementing private_r_mutex_t?
+ */
+ bool recursive;
+
+ /**
+ * profiling info, if enabled
+ */
+ lock_profile_t profile;
+};
+
+/**
+ * private data of mutex, extended by recursive locking information
+ */
+struct private_r_mutex_t {
+
+ /**
+ * Extends private_mutex_t
+ */
+ private_mutex_t generic;
+
+ /**
+ * thread which currently owns mutex
+ */
+ pthread_t thread;
+
+ /**
+ * times we have locked the lock, stored per thread
+ */
+ pthread_key_t times;
+};
+
/**
* Implementation of mutex_t.lock.
*/
/*
- * Copyright (C) 2008 Tobias Brunner
+ * Copyright (C) 2008-2009 Tobias Brunner
* Copyright (C) 2008 Martin Willi
* Hochschule fuer Technik Rapperswil
*
* for more details.
*/
+/**
+ * @defgroup mutex mutex
+ * @{ @ingroup threading
+ */
+
#ifndef THREADING_MUTEX_H_
#define THREADING_MUTEX_H_
-#include "lock_profiler.h"
+typedef struct mutex_t mutex_t;
+typedef enum mutex_type_t mutex_type_t;
-typedef struct private_mutex_t private_mutex_t;
-typedef struct private_r_mutex_t private_r_mutex_t;
+#include "condvar.h"
-/**
- * private data of mutex
+#ifdef __APPLE__
+/* on Mac OS X 10.5 several system calls we use are no cancellation points.
+ * fortunately, select isn't one of them, so we wrap some of the others with
+ * calls to select(2).
*/
-struct private_mutex_t {
+#include <sys/socket.h>
+#include <sys/select.h>
- /**
- * public functions
- */
- mutex_t public;
+#define WRAP_WITH_SELECT(func, socket, ...)\
+ fd_set rfds; FD_ZERO(&rfds); FD_SET(socket, &rfds);\
+ if (select(socket + 1, &rfds, NULL, NULL, NULL) <= 0) { return -1; }\
+ return func(socket, __VA_ARGS__)
- /**
- * wrapped pthread mutex
- */
- pthread_mutex_t mutex;
+static inline int cancellable_accept(int socket, struct sockaddr *address,
+ socklen_t *address_len)
+{
+ WRAP_WITH_SELECT(accept, socket, address, address_len);
+}
+#define accept cancellable_accept
+static inline int cancellable_recvfrom(int socket, void *buffer, size_t length,
+ int flags, struct sockaddr *address, socklen_t *address_len)
+{
+ WRAP_WITH_SELECT(recvfrom, socket, buffer, length, flags, address, address_len);
+}
+#define recvfrom cancellable_recvfrom
+#endif /* __APPLE__ */
- /**
- * is this a recursiv emutex, implementing private_r_mutex_t?
- */
- bool recursive;
-
- /**
- * profiling info, if enabled
- */
- lock_profile_t profile;
+/**
+ * Type of mutex.
+ */
+enum mutex_type_t {
+ /** default mutex */
+ MUTEX_TYPE_DEFAULT = 0,
+ /** allow recursive locking of the mutex */
+ MUTEX_TYPE_RECURSIVE = 1,
};
/**
- * private data of mutex, extended by recursive locking information
+ * Mutex wrapper implements simple, portable and advanced mutex functions.
*/
-struct private_r_mutex_t {
+struct mutex_t {
/**
- * Extends private_mutex_t
+ * Acquire the lock to the mutex.
*/
- private_mutex_t generic;
+ void (*lock)(mutex_t *this);
/**
- * thread which currently owns mutex
+ * Release the lock on the mutex.
*/
- pthread_t thread;
+ void (*unlock)(mutex_t *this);
/**
- * times we have locked the lock, stored per thread
+ * Destroy a mutex instance.
*/
- pthread_key_t times;
+ void (*destroy)(mutex_t *this);
};
-#endif /* THREADING_MUTEX_H_ */
+/**
+ * Create a mutex instance.
+ *
+ * @param type type of mutex to create
+ * @return unlocked mutex instance
+ */
+mutex_t *mutex_create(mutex_type_t type);
+
+#endif /** THREADING_MUTEX_H_ @} */
#define _GNU_SOURCE
#include <pthread.h>
-#include <threading.h>
#include <library.h>
#include <debug.h>
#include "rwlock.h"
+#include "condvar.h"
+#include "mutex.h"
#include "lock_profiler.h"
+typedef struct private_rwlock_t private_rwlock_t;
+
+/**
+ * private data of rwlock
+ */
+struct private_rwlock_t {
+
+ /**
+ * public functions
+ */
+ rwlock_t public;
+
+#ifdef HAVE_PTHREAD_RWLOCK_INIT
+
+ /**
+ * wrapped pthread rwlock
+ */
+ pthread_rwlock_t rwlock;
+
+#else
+
+ /**
+ * mutex to emulate a native rwlock
+ */
+ mutex_t *mutex;
+
+ /**
+ * condvar to handle writers
+ */
+ condvar_t *writers;
+
+ /**
+ * condvar to handle readers
+ */
+ condvar_t *readers;
+
+ /**
+ * number of waiting writers
+ */
+ u_int waiting_writers;
+
+ /**
+ * number of readers holding the lock
+ */
+ u_int reader_count;
+
+ /**
+ * current writer thread, if any
+ */
+ pthread_t writer;
+
+#endif /* HAVE_PTHREAD_RWLOCK_INIT */
+
+ /**
+ * profiling info, if enabled
+ */
+ lock_profile_t profile;
+};
+
+
#ifdef HAVE_PTHREAD_RWLOCK_INIT
/**
/*
- * Copyright (C) 2008 Tobias Brunner
+ * Copyright (C) 2008-2009 Tobias Brunner
* Copyright (C) 2008 Martin Willi
* Hochschule fuer Technik Rapperswil
*
* for more details.
*/
+/**
+ * @defgroup rwlock rwlock
+ * @{ @ingroup threading
+ */
+
#ifndef THREADING_RWLOCK_H_
#define THREADING_RWLOCK_H_
-#include "lock_profiler.h"
-
-typedef struct private_rwlock_t private_rwlock_t;
+typedef struct rwlock_t rwlock_t;
+typedef enum rwlock_type_t rwlock_type_t;
/**
- * private data of rwlock
+ * Type of read-write lock.
*/
-struct private_rwlock_t {
-
- /**
- * public functions
- */
- rwlock_t public;
-
-#ifdef HAVE_PTHREAD_RWLOCK_INIT
-
- /**
- * wrapped pthread rwlock
- */
- pthread_rwlock_t rwlock;
-
-#else
-
- /**
- * mutex to emulate a native rwlock
- */
- mutex_t *mutex;
+enum rwlock_type_t {
+ /** default condvar */
+ RWLOCK_TYPE_DEFAULT = 0,
+};
- /**
- * condvar to handle writers
- */
- condvar_t *writers;
+/**
+ * Read-Write lock wrapper.
+ */
+struct rwlock_t {
/**
- * condvar to handle readers
+ * Acquire the read lock.
*/
- condvar_t *readers;
+ void (*read_lock)(rwlock_t *this);
/**
- * number of waiting writers
+ * Acquire the write lock.
*/
- u_int waiting_writers;
+ void (*write_lock)(rwlock_t *this);
/**
- * number of readers holding the lock
+ * Try to acquire the write lock.
+ *
+ * Never blocks, but returns FALSE if the lock was already occupied.
+ *
+ * @return TRUE if lock acquired
*/
- u_int reader_count;
+ bool (*try_write_lock)(rwlock_t *this);
/**
- * current writer thread, if any
+ * Release any acquired lock.
*/
- pthread_t writer;
-
-#endif /* HAVE_PTHREAD_RWLOCK_INIT */
+ void (*unlock)(rwlock_t *this);
/**
- * profiling info, if enabled
+ * Destroy the read-write lock.
*/
- lock_profile_t profile;
+ void (*destroy)(rwlock_t *this);
};
-#endif /* THREADING_THREADING_H_ */
+/**
+ * Create a read-write lock instance.
+ *
+ * @param type type of rwlock to create
+ * @return unlocked rwlock instance
+ */
+rwlock_t *rwlock_create(rwlock_type_t type);
+
+#endif /** THREADING_RWLOCK_H_ @} */
projects / thirdparty / strongswan.git / commitdiff
