From 01839d4e4877ec5a8ab47c49f5636ed24185cac4 Mon Sep 17 00:00:00 2001 From: Christian Thaeter Date: Wed, 3 Feb 2010 10:38:12 +0100 Subject: [PATCH] update for nobug-201002.1 --- configure.ac | 2 +- src/lib/condition.c | 21 ++++--- src/lib/condition.h | 95 ++++++++++++++-------------- src/lib/mutex.c | 14 +++-- src/lib/mutex.h | 61 +++++++++--------- src/lib/reccondition.c | 21 ++++--- src/lib/reccondition.h | 97 +++++++++++++++-------------- src/lib/recmutex.c | 14 +++-- src/lib/recmutex.h | 61 +++++++++--------- src/lib/rwlock.c | 14 +++-- src/lib/rwlock.h | 136 +++++++++++++++++++++-------------------- tests/test.conf | 2 +- tests/test.sh | 6 +- 13 files changed, 291 insertions(+), 253 deletions(-) diff --git a/configure.ac b/configure.ac index 9e0e43e30..34091e389 100644 --- a/configure.ac +++ b/configure.ac @@ -92,7 +92,7 @@ AC_CHECK_HEADER([execinfo.h], AC_DEFINE(HAVE_EXECINFO_H)) PKG_CHECK_MODULES(VALGRIND, [valgrind], AC_DEFINE(HAVE_VALGRIND_H), AC_MSG_NOTICE([valgrind not found (optional)])) -PKG_CHECK_MODULES(NOBUGMT, [nobugmt >= 201001.2], +PKG_CHECK_MODULES(NOBUGMT, [nobugmt >= 201002.1], AC_DEFINE(HAVE_NOBUGMT_H), AC_MSG_ERROR([Missing required nobug version (http://www.lumiera.org/nobug_manual.html)]) ) diff --git a/src/lib/condition.c b/src/lib/condition.c index 97a0593d9..7c2d31d8e 100644 --- a/src/lib/condition.c +++ b/src/lib/condition.c @@ -35,10 +35,12 @@ lumiera_condition_init (LumieraCondition self, { if (self) { - pthread_cond_init (&self->cond, NULL); - pthread_mutex_init (&self->cndmutex, NULL); NOBUG_RESOURCE_HANDLE_INIT (self->rh); - NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "cond_var", purpose, self, self->rh, ctx); + NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "cond_var", purpose, self, self->rh, ctx) + { + pthread_mutex_init (&self->cndmutex, NULL); + pthread_cond_init (&self->cond, NULL); + } } return self; } @@ -51,13 +53,14 @@ lumiera_condition_destroy (LumieraCondition self, { if (self) { - NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx); + NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx) + { + if (pthread_mutex_destroy (&self->cndmutex)) + LUMIERA_DIE (LOCK_DESTROY); - if (pthread_mutex_destroy (&self->cndmutex)) - LUMIERA_DIE (LOCK_DESTROY); - - if (pthread_cond_destroy (&self->cond)) - LUMIERA_DIE (LOCK_DESTROY); + if (pthread_cond_destroy (&self->cond)) + LUMIERA_DIE (LOCK_DESTROY); + } } return self; } diff --git a/src/lib/condition.h b/src/lib/condition.h index 752f23fd1..db06d5441 100644 --- a/src/lib/condition.h +++ b/src/lib/condition.h @@ -194,12 +194,13 @@ lumiera_condition_lock (LumieraCondition self, { if (self) { - NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire condvar", *handle, ctx); + NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire condvar", *handle, ctx) + { + if (pthread_mutex_lock (&self->cndmutex)) + LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - if (pthread_mutex_lock (&self->cndmutex)) - LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } } return self; @@ -214,19 +215,20 @@ lumiera_condition_trylock (LumieraCondition self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire condvar", *handle, ctx); - - int err = pthread_mutex_trylock (&self->cndmutex); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire condvar", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_trylock (&self->cndmutex); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -243,19 +245,20 @@ lumiera_condition_timedlock (LumieraCondition self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire condvar", *handle, ctx); - - int err = pthread_mutex_timedlock (&self->cndmutex, timeout); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire condvar", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_timedlock (&self->cndmutex, timeout); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -271,11 +274,12 @@ lumiera_condition_wait (LumieraCondition self, { if (self) { - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx); + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx) + { + pthread_cond_wait (&self->cond, &self->cndmutex); - pthread_cond_wait (&self->cond, &self->cndmutex); - - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } } return self; } @@ -290,19 +294,20 @@ lumiera_condition_timedwait (LumieraCondition self, { if (self) { - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx); - - int err; - do { - err = pthread_cond_timedwait (&self->cond, &self->cndmutex, timeout); - } while(err == EINTR); - - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); - - if (err) + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx) { - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err; + do { + err = pthread_cond_timedwait (&self->cond, &self->cndmutex, timeout); + } while(err == EINTR); + + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + + if (err) + { + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } diff --git a/src/lib/mutex.c b/src/lib/mutex.c index eb1e0dc93..baaa39b07 100644 --- a/src/lib/mutex.c +++ b/src/lib/mutex.c @@ -34,9 +34,11 @@ lumiera_mutex_init (LumieraMutex self, { if (self) { - pthread_mutex_init (&self->mutex, NULL); NOBUG_RESOURCE_HANDLE_INIT (self->rh); - NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "mutex", purpose, self, self->rh, ctx); + NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "mutex", purpose, self, self->rh, ctx) + { + pthread_mutex_init (&self->mutex, NULL); + } } return self; } @@ -49,9 +51,11 @@ lumiera_mutex_destroy (LumieraMutex self, { if (self) { - NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx); - if (pthread_mutex_destroy (&self->mutex)) - LUMIERA_DIE (LOCK_DESTROY); + NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx) + { + if (pthread_mutex_destroy (&self->mutex)) + LUMIERA_DIE (LOCK_DESTROY); + } } return self; } diff --git a/src/lib/mutex.h b/src/lib/mutex.h index 2f60d46fd..ec9215e04 100644 --- a/src/lib/mutex.h +++ b/src/lib/mutex.h @@ -142,12 +142,13 @@ lumiera_mutex_lock (LumieraMutex self, { if (self) { - NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire mutex", *handle, ctx); + NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire mutex", *handle, ctx) + { + if (pthread_mutex_lock (&self->mutex)) + LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - if (pthread_mutex_lock (&self->mutex)) - LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } } return self; @@ -169,19 +170,20 @@ lumiera_mutex_trylock (LumieraMutex self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire mutex", *handle, ctx); - - int err = pthread_mutex_trylock (&self->mutex); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire mutex", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_trylock (&self->mutex); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -205,19 +207,20 @@ lumiera_mutex_timedlock (LumieraMutex self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire mutex", *handle, ctx); - - int err = pthread_mutex_timedlock (&self->mutex, timeout); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire mutex", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_timedlock (&self->mutex, timeout); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } diff --git a/src/lib/reccondition.c b/src/lib/reccondition.c index f5d6e4fb5..01feab0ee 100644 --- a/src/lib/reccondition.c +++ b/src/lib/reccondition.c @@ -48,10 +48,12 @@ lumiera_reccondition_init (LumieraReccondition self, { pthread_once (&recursive_mutexattr_once, recursive_mutexattr_init); - pthread_cond_init (&self->cond, NULL); - pthread_mutex_init (&self->reccndmutex, &recursive_mutexattr); NOBUG_RESOURCE_HANDLE_INIT (self->rh); - NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "reccond_var", purpose, self, self->rh, ctx); + NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "reccond_var", purpose, self, self->rh, ctx) + { + pthread_mutex_init (&self->reccndmutex, &recursive_mutexattr); + pthread_cond_init (&self->cond, NULL); + } } return self; } @@ -64,13 +66,14 @@ lumiera_reccondition_destroy (LumieraReccondition self, { if (self) { - NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx); + NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx) + { + if (pthread_mutex_destroy (&self->reccndmutex)) + LUMIERA_DIE (LOCK_DESTROY); - if (pthread_mutex_destroy (&self->reccndmutex)) - LUMIERA_DIE (LOCK_DESTROY); - - if (pthread_cond_destroy (&self->cond)) - LUMIERA_DIE (LOCK_DESTROY); + if (pthread_cond_destroy (&self->cond)) + LUMIERA_DIE (LOCK_DESTROY); + } } return self; } diff --git a/src/lib/reccondition.h b/src/lib/reccondition.h index 99259712f..418d8556b 100644 --- a/src/lib/reccondition.h +++ b/src/lib/reccondition.h @@ -196,12 +196,12 @@ lumiera_reccondition_lock (LumieraReccondition self, { if (self) { - NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire reccondvar", *handle, ctx); - - if (pthread_mutex_lock (&self->reccndmutex)) - LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx); + NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire reccondvar", *handle, ctx) + { + if (pthread_mutex_lock (&self->reccndmutex)) + LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + } } return self; @@ -216,19 +216,20 @@ lumiera_reccondition_trylock (LumieraReccondition self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire reccondvar", *handle, ctx); - - int err = pthread_mutex_trylock (&self->reccndmutex); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire reccondvar", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_trylock (&self->reccndmutex); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -245,19 +246,20 @@ lumiera_reccondition_timedlock (LumieraReccondition self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire reccondvar", *handle, ctx); - - int err = pthread_mutex_timedlock (&self->reccndmutex, timeout); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire reccondvar", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_timedlock (&self->reccndmutex, timeout); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -273,11 +275,11 @@ lumiera_reccondition_wait (LumieraReccondition self, { if (self) { - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx); - - pthread_cond_wait (&self->cond, &self->reccndmutex); - - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_RECURSIVE, *handle, ctx); + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx) + { + pthread_cond_wait (&self->cond, &self->reccndmutex); + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + } } return self; } @@ -292,19 +294,20 @@ lumiera_reccondition_timedwait (LumieraReccondition self, { if (self) { - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx); - - int err; - do { - err = pthread_cond_timedwait (&self->cond, &self->reccndmutex, timeout); - } while(err == EINTR); - - NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_RECURSIVE, *handle, ctx); - - if (err) + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_WAITING, *handle, ctx) { - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err; + do { + err = pthread_cond_timedwait (&self->cond, &self->reccndmutex, timeout); + } while(err == EINTR); + + if (!err) + NOBUG_RESOURCE_STATE_RAW_CTX (flag, NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + else + { + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } diff --git a/src/lib/recmutex.c b/src/lib/recmutex.c index 7a852c2a1..ca3c2f37c 100644 --- a/src/lib/recmutex.c +++ b/src/lib/recmutex.c @@ -47,9 +47,11 @@ lumiera_recmutex_init (LumieraRecmutex self, { pthread_once (&recmutexattr_once, recmutexattr_init); - pthread_mutex_init (&self->recmutex, &recmutexattr); NOBUG_RESOURCE_HANDLE_INIT (self->rh); - NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "recmutex", purpose, self, self->rh, ctx); + NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "recmutex", purpose, self, self->rh, ctx) + { + pthread_mutex_init (&self->recmutex, &recmutexattr); + } } return self; @@ -63,9 +65,11 @@ lumiera_recmutex_destroy (LumieraRecmutex self, { if (self) { - NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx); - if (pthread_mutex_destroy (&self->recmutex)) - LUMIERA_DIE (LOCK_DESTROY); + NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx) + { + if (pthread_mutex_destroy (&self->recmutex)) + LUMIERA_DIE (LOCK_DESTROY); + } } return self; } diff --git a/src/lib/recmutex.h b/src/lib/recmutex.h index 8383e6210..18dff4acf 100644 --- a/src/lib/recmutex.h +++ b/src/lib/recmutex.h @@ -124,12 +124,13 @@ lumiera_recmutex_lock (LumieraRecmutex self, { if (self) { - NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire mutex", *handle, ctx); + NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire mutex", *handle, ctx) + { + if (pthread_mutex_lock (&self->recmutex)) + LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - if (pthread_mutex_lock (&self->recmutex)) - LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx); + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + } } return self; @@ -144,19 +145,20 @@ lumiera_recmutex_trylock (LumieraRecmutex self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire mutex", *handle, ctx); - - int err = pthread_mutex_trylock (&self->recmutex); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire mutex", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_trylock (&self->recmutex); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -173,19 +175,20 @@ lumiera_recmutex_timedlock (LumieraRecmutex self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire mutex", *handle, ctx); - - int err = pthread_mutex_timedlock (&self->recmutex, timeout); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire mutex", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_mutex_timedlock (&self->recmutex, timeout); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_RECURSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } diff --git a/src/lib/rwlock.c b/src/lib/rwlock.c index 349af6dff..03d70b7e3 100644 --- a/src/lib/rwlock.c +++ b/src/lib/rwlock.c @@ -36,9 +36,11 @@ lumiera_rwlock_init (LumieraRWLock self, { if (self) { - pthread_rwlock_init (&self->rwlock, NULL); NOBUG_RESOURCE_HANDLE_INIT (self->rh); - NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "rwlock", purpose, self, self->rh, ctx); + NOBUG_RESOURCE_ANNOUNCE_RAW_CTX (flag, "rwlock", purpose, self, self->rh, ctx) + { + pthread_rwlock_init (&self->rwlock, NULL); + } } return self; } @@ -51,9 +53,11 @@ lumiera_rwlock_destroy (LumieraRWLock self, { if (self) { - NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx); - if (pthread_rwlock_destroy (&self->rwlock)) - LUMIERA_DIE (LOCK_DESTROY); + NOBUG_RESOURCE_FORGET_RAW_CTX (flag, self->rh, ctx) + { + if (pthread_rwlock_destroy (&self->rwlock)) + LUMIERA_DIE (LOCK_DESTROY); + } } return self; } diff --git a/src/lib/rwlock.h b/src/lib/rwlock.h index f651f7b24..79b019660 100644 --- a/src/lib/rwlock.h +++ b/src/lib/rwlock.h @@ -170,19 +170,20 @@ lumiera_rwlock_rdlock (LumieraRWLock self, { if (self) { - NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire rwlock for reading", *handle, ctx); - - int err = pthread_rwlock_rdlock (&self->rwlock); - - if (!err) + NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire rwlock for reading", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_SHARED, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_rwlock_rdlock (&self->rwlock); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_SHARED, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -198,19 +199,20 @@ lumiera_rwlock_tryrdlock (LumieraRWLock self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire rwlock for reading", *handle, ctx); - - int err = pthread_rwlock_tryrdlock (&self->rwlock); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire rwlock for reading", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_SHARED, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_rwlock_tryrdlock (&self->rwlock); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_SHARED, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -227,19 +229,20 @@ lumiera_rwlock_timedrdlock (LumieraRWLock self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire rwlock for reading", *handle, ctx); - - int err = pthread_rwlock_timedrdlock (&self->rwlock, timeout); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire rwlock for reading", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_SHARED, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_rwlock_timedrdlock (&self->rwlock, timeout); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_SHARED, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -255,12 +258,13 @@ lumiera_rwlock_wrlock (LumieraRWLock self, { if (self) { - NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire rwlock for writing", *handle, ctx); + NOBUG_RESOURCE_WAIT_CTX (NOBUG_FLAG_RAW(flag), self->rh, "acquire rwlock for writing", *handle, ctx) + { + if (pthread_rwlock_wrlock (&self->rwlock)) + LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - if (pthread_rwlock_wrlock (&self->rwlock)) - LUMIERA_DIE (LOCK_ACQUIRE); /* never reached (in a correct program) */ - - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } } return self; @@ -275,19 +279,20 @@ lumiera_rwlock_trywrlock (LumieraRWLock self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire rwlock for writing", *handle, ctx); - - int err = pthread_rwlock_trywrlock (&self->rwlock); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "try acquire rwlock for writing", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_rwlock_trywrlock (&self->rwlock); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } @@ -304,19 +309,20 @@ lumiera_rwlock_timedwrlock (LumieraRWLock self, { if (self) { - NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire rwlock for writing", *handle, ctx); - - int err = pthread_rwlock_timedwrlock (&self->rwlock, timeout); - - if (!err) + NOBUG_RESOURCE_TRY_CTX (NOBUG_FLAG_RAW(flag), self->rh, "timed acquire rwlock for writing", *handle, ctx) { - NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx); - } - else - { - NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; - lumiera_lockerror_set (err, flag, ctx); - return NULL; + int err = pthread_rwlock_timedwrlock (&self->rwlock, timeout); + + if (!err) + { + NOBUG_RESOURCE_STATE_CTX (NOBUG_FLAG_RAW(flag), NOBUG_RESOURCE_EXCLUSIVE, *handle, ctx) /*{}*/; + } + else + { + NOBUG_RESOURCE_LEAVE_RAW_CTX (flag, *handle, ctx) /*{}*/; + lumiera_lockerror_set (err, flag, ctx); + self = NULL; + } } } diff --git a/tests/test.conf b/tests/test.conf index 662175123..38cf8082d 100755 --- a/tests/test.conf +++ b/tests/test.conf @@ -1 +1 @@ -LOGSUPPRESS='^\(\*\*[0-9]*\*\* \)\?[0-9]\{10,\}: \(TRACE\|INFO\|NOTICE\|WARNING\|ERR\|TODO\|PLANNED\|FIXME\|DEPRECATED\|UNIMPLEMENTED\|RESOURCE_ANNOUNCE\|RESOURCE_ENTER\|RESOURCE_STATE\|RESOURCE_LEAVE\):' +LOGSUPPRESS='^\(\*\*[0-9]*\*\* \)\?[0-9]\{10,\}[:!] \(TRACE\|INFO\|NOTICE\|WARNING\|ERR\|TODO\|PLANNED\|FIXME\|DEPRECATED\|UNIMPLEMENTED\|RESOURCE_ANNOUNCE\|RESOURCE_ENTER\|RESOURCE_STATE\|RESOURCE_LEAVE\):' diff --git a/tests/test.sh b/tests/test.sh index 19df30e38..2b239ebed 100755 --- a/tests/test.sh +++ b/tests/test.sh @@ -1,6 +1,6 @@ #!/usr/bin/env bash -# Copyright (C) Lumiera.org -# 2007 - 2010, Christian Thaeter +# Copyright (C) Lumiera.org +# 2007, 2008, 2009, 2010, Christian Thaeter # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as @@ -59,7 +59,7 @@ LC_ALL=C #config validating the output the `LOGSUPRESS` variable can be set to a regex to filter this things out. #config The default as shown above filters some NoBug annotations and non fatal logging out. #config -LOGSUPPRESS='^\(\*\*[0-9]*\*\* \)\?[0-9]\{10,\}: \(TRACE\|INFO\|NOTICE\|WARNING\|ERR\):' +LOGSUPPRESS='^\(\*\*[0-9]*\*\* \)\?[0-9]\{10,\}[:!] \(TRACE\|INFO\|NOTICE\|WARNING\|ERR\):' #config PARA Resource Limits; ulimit; constrain resource limits #config It is possible to set some limits for tests to protect the system against really broken cases.