benn/lumiera_documentation
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

update for nobug-201002.1

Browse source
This commit is contained in:
Christian Thaeter 2010-02-03 10:38:12 +01:00
parent 014c83ff5a
commit 01839d4e48
13 changed files with 291 additions and 253 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
configure.ac
View file

@ -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)])
)

21
src/lib/condition.c
View file

@ -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;
}

95
src/lib/condition.h
View file

@ -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;
}
}
}

14
src/lib/mutex.c
View file

@ -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;
}

61
src/lib/mutex.h
View file

@ -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;
}
}
}

21
src/lib/reccondition.c
View file

@ -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;
}

97
src/lib/reccondition.h
View file

@ -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;
}
}
}

14
src/lib/recmutex.c
View file

@ -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;
}

61
src/lib/recmutex.h
View file

@ -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;
}
}
}

14
src/lib/rwlock.c
View file

@ -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;
}

136
src/lib/rwlock.h
View file

@ -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;
}
}
}

2
tests/test.conf
View file

@ -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\):'

6
tests/test.sh
View file

@ -1,6 +1,6 @@
#!/usr/bin/env bash
# Copyright (C) Lumiera.org
# 2007 - 2010, Christian Thaeter <ct@pipapo.org>
# Copyright (C) Lumiera.org
# 2007, 2008, 2009, 2010, Christian Thaeter <ct@pipapo.org>
#
# 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.