void _ump_osu_lock_term( _ump_osu_lock_t *lock )
{
int call_result;
UMP_DEBUG_ASSERT_POINTER( lock );
/** Debug lock checking: */
/* Lock is signalled on terminate - not a guarantee, since we could be locked immediately beforehand */
UMP_DEBUG_ASSERT( _UMP_OSU_LOCKMODE_UNDEF == lock->locked_as,
("cannot terminate held lock\n") );
call_result = pthread_mutex_destroy( &lock->mutex );
UMP_DEBUG_ASSERT( 0 == call_result,
("Incorrect mutex use detected: pthread_mutex_destroy call failed with error code %d\n", call_result) );
/* Destroy extra state for ANY_UNLOCK type osu_locks */
if ( lock->flags & _UMP_OSU_LOCKFLAG_ANYUNLOCK )
{
UMP_DEBUG_ASSERT( UMP_FALSE == lock->state, ("terminate called on locked object %p\n", lock));
call_result = pthread_cond_destroy(&lock->condition);
UMP_DEBUG_ASSERT( 0 == call_result,
("Incorrect condition-variable use detected: pthread_cond_destroy call failed with error code %d\n", call_result) );
}
UMP_IGNORE(call_result);
_ump_osu_free( lock );
}
_ump_osu_errcode_t _ump_osu_lock_wait( _ump_osu_lock_t *lock, _ump_osu_lock_mode_t mode)
{
/* Parameter validation */
UMP_DEBUG_ASSERT_POINTER( lock );
UMP_DEBUG_ASSERT( _UMP_OSU_LOCKMODE_RW == mode,
("unrecognised mode, %.8X\n", mode) );
/** @note since only one flag can be set, we use a switch statement here.
* Otherwise, MUST add an enum into the _ump_osu_lock_t to store the
* implemented lock type */
switch ( lock->flags )
{
case _UMP_OSU_LOCKFLAG_STATIC:
case _UMP_OSU_LOCKFLAG_DEFAULT:
/* Usual Mutex type */
{
int call_result;
call_result = pthread_mutex_lock( &lock->mutex );
UMP_DEBUG_ASSERT( 0 == call_result,
("pthread_mutex_lock call failed with error code %d\n", call_result));
UMP_IGNORE( call_result );
}
/* DEBUG tracking of previously locked state - occurs while lock is obtained */
UMP_DEBUG_ASSERT( _UMP_OSU_LOCKMODE_UNDEF == lock->locked_as,
("This lock was already locked\n") );
UMP_DEBUG_CODE( lock->locked_as = mode );
break;
case _UMP_OSU_LOCKFLAG_ANYUNLOCK:
/** @note Use of bitflags in a case statement ONLY works because this
* is the ONLY flag that is supported */
/* lock the mutex protecting access to the state field */
pthread_mutex_lock( &lock->mutex );
/* loop while locked (state is UMP_TRUE) */
/* pthread_cond_wait unlocks the mutex, wait, and locks the mutex once unblocked */
while ( UMP_TRUE == lock->state ) pthread_cond_wait( &lock->condition, &lock->mutex );
/* DEBUG tracking of previously locked state - occurs while lock is obtained */
UMP_DEBUG_ASSERT( _UMP_OSU_LOCKMODE_UNDEF == lock->locked_as,
("This lock was already locked\n") );
UMP_DEBUG_CODE( lock->locked_as = mode );
/* the state is UMP_FALSE (unlocked), so we set it to UMP_TRUE to indicate that it's locked and can return knowing that we own the lock */
lock->state = UMP_TRUE;
/* final unlock of the mutex */
pthread_mutex_unlock(&lock->mutex);
break;
default:
UMP_DEBUG_ERROR( ("lock has incorrect flags==%.8X\n", lock->flags) );
break;
}
return _UMP_OSU_ERR_OK;
}
void _ump_osu_lock_signal( _ump_osu_lock_t *lock, _ump_osu_lock_mode_t mode )
{
/* Parameter validation */
UMP_DEBUG_ASSERT_POINTER( lock );
UMP_DEBUG_ASSERT( _UMP_OSU_LOCKMODE_RW == mode,
("unrecognised mode, %.8X\n", mode) );
/** @note since only one flag can be set, we use a switch statement here.
* Otherwise, MUST add an enum into the _ump_osu_lock_t to store the
* implemented lock type */
switch ( lock->flags )
{
case _UMP_OSU_LOCKFLAG_STATIC:
case _UMP_OSU_LOCKFLAG_DEFAULT:
/* Usual Mutex type */
/* DEBUG tracking of previously locked state - occurs while lock is obtained */
UMP_DEBUG_ASSERT( mode == lock->locked_as,
("This lock was locked as==%.8X, but tried to unlock as mode==%.8X\n", lock->locked_as, mode));
UMP_DEBUG_CODE( lock->locked_as = _UMP_OSU_LOCKMODE_UNDEF );
{
int call_result;
call_result = pthread_mutex_unlock( &lock->mutex );
UMP_DEBUG_ASSERT( 0 == call_result,
("pthread_mutex_lock call failed with error code %d\n", call_result));
UMP_IGNORE( call_result );
}
break;
case _UMP_OSU_LOCKFLAG_ANYUNLOCK:
/** @note Use of bitflags in a case statement ONLY works because this
* is the ONLY flag that is supported */
pthread_mutex_lock(&lock->mutex);
UMP_DEBUG_ASSERT( UMP_TRUE == lock->state, ("Unlocking a _ump_osu_lock_t %p which is not locked\n", lock));
/* DEBUG tracking of previously locked state - occurs while lock is obtained */
UMP_DEBUG_ASSERT( mode == lock->locked_as,
("This lock was locked as==%.8X, but tried to unlock as %.8X\n", lock->locked_as, mode ));
UMP_DEBUG_CODE( lock->locked_as = _UMP_OSU_LOCKMODE_UNDEF );
/* mark as unlocked */
lock->state = UMP_FALSE;
/* signal the condition, only wake a single thread */
pthread_cond_signal(&lock->condition);
pthread_mutex_unlock(&lock->mutex);
break;
default:
UMP_DEBUG_ERROR( ("lock has incorrect flags==%.8X\n", lock->flags) );
break;
}
}
_ump_osu_errcode_t _ump_osu_lock_auto_init( _ump_osu_lock_t **pplock, _ump_osu_lock_flags_t flags, u32 initial, u32 order )
{
int call_result;
/* Validate parameters: */
UMP_DEBUG_ASSERT_POINTER( pplock );
/** @opt We don't lock the Critical Section or do anything if this is already non-null */
if ( NULL != *pplock)
{
return _UMP_OSU_ERR_OK;
}
/* We MIGHT need to initialize it, lock the Critical Section and check again */
call_result = pthread_mutex_lock(&static_auto_init_mutex);
/* It would be a programming error for this to fail: */
UMP_DEBUG_ASSERT( 0 == call_result,
("failed to lock critical section\n") );
if ( NULL != *pplock )
{
/*
We caught a race condition to initialize this osu_lock.
The other thread won the race, so the osu_lock is now initialized.
*/
call_result = pthread_mutex_unlock(&static_auto_init_mutex);
UMP_DEBUG_ASSERT(0 == call_result,
("failed to unlock critical section\n"));
return _UMP_OSU_ERR_OK;
}
/* We're the first thread in: initialize the osu_lock */
*pplock = _ump_osu_lock_init( flags, initial, order );
if ( NULL == *pplock )
{
/* osu_lock creation failed */
call_result = pthread_mutex_unlock(&static_auto_init_mutex);
UMP_DEBUG_ASSERT(0 == call_result,
("failed to unlock critical section\n"));
return _UMP_OSU_ERR_FAULT;
}
/* osu_lock created OK */
call_result = pthread_mutex_unlock(&static_auto_init_mutex);
UMP_DEBUG_ASSERT(0 == call_result,
("failed to unlock critical section\n"));
UMP_IGNORE( call_result );
return _UMP_OSU_ERR_OK;
}
void ump_arch_close(void)
{
_ump_osu_lock_auto_init(&ump_lock_arch, _UMP_OSU_LOCKFLAG_DEFAULT, 0, 0);
/* Check that the lock was initialized */
if (NULL == ump_lock_arch)
{
UMP_DEBUG_PRINT(1, ("UMP: ump_arch_close() failed to init lock\n"));
return;
}
/* Attempt to obtain a lock */
if (_UMP_OSU_ERR_OK != _ump_osu_lock_wait(ump_lock_arch, _UMP_OSU_LOCKMODE_RW))
{
UMP_DEBUG_PRINT(1, ("UMP: ump_arch_close() failed to acquire lock\n"));
return;
}
UMP_DEBUG_ASSERT(0 < ump_ref_count, ("UMP: ump_arch_close() called while no references exist"));
if (ump_ref_count > 0)
{
ump_ref_count--;
if (0 == ump_ref_count)
{
_ump_osu_errcode_t retval = _ump_uku_close(&ump_uk_ctx);
UMP_DEBUG_ASSERT(retval == _UMP_OSU_ERR_OK, ("UMP: Failed to close UMP interface"));
UMP_IGNORE(retval);
ump_uk_ctx = NULL;
_ump_osu_lock_signal(ump_lock_arch, _UMP_OSU_LOCKMODE_RW);
_ump_osu_lock_term(ump_lock_arch); /* Not 100% thread safe, since another thread can already be waiting for this lock in ump_arch_open() */
ump_lock_arch = NULL;
return;
}
}
/* Signal the lock so someone else can use it */
_ump_osu_lock_signal(ump_lock_arch, _UMP_OSU_LOCKMODE_RW);
}
_ump_osu_lock_t *_ump_osu_lock_init( _ump_osu_lock_flags_t flags, u32 initial, u32 order )
{
_ump_osu_lock_t * lock;
pthread_mutexattr_t mutex_attributes;
UMP_IGNORE(order); /* order isn't implemented yet, for now callers should set it to zero. */
/* Validate parameters: */
/* Flags acceptable */
UMP_DEBUG_ASSERT( 0 == ( flags & ~( _UMP_OSU_LOCKFLAG_ANYUNLOCK)),
("incorrect flags or trying to initialise a statically initialized lock, %.8X\n", flags) );
/* Parameter initial SBZ - for future expansion */
UMP_DEBUG_ASSERT( 0 == initial,
("initial must be zero\n") );
if (0 != pthread_mutexattr_init(&mutex_attributes))
{
return NULL;
}
#if UMP_DEBUG_EXTENDED_MUTEX_LOCK_CHECKING
#define UMP_PTHREADS_MUTEX_TYPE PTHREAD_MUTEX_ERRORCHECK
#else
#define UMP_PTHREADS_MUTEX_TYPE PTHREAD_MUTEX_DEFAULT
#endif
if (0 != pthread_mutexattr_settype(&mutex_attributes, UMP_PTHREADS_MUTEX_TYPE))
{
/** Return NULL on failure */
pthread_mutexattr_destroy(&mutex_attributes);
return NULL;
}
#undef UMP_PTHREADS_MUTEX_TYPE
/** @opt use containing structures for the ANY_UNLOCK type, to
* save 2 DWORDS when not in use */
lock = _ump_osu_malloc( sizeof(_ump_osu_lock_t) );
if( NULL == lock )
{
/** Return NULL on failure */
pthread_mutexattr_destroy(&mutex_attributes);
return NULL;
}
if (0 != pthread_mutex_init( &lock->mutex, &mutex_attributes ))
{
pthread_mutexattr_destroy(&mutex_attributes);
_ump_osu_free( lock );
return NULL;
}
/* done with the mutexattr object */
pthread_mutexattr_destroy(&mutex_attributes);
/* ANY_UNLOCK type */
if ( flags & _UMP_OSU_LOCKFLAG_ANYUNLOCK )
{
if (0 != pthread_cond_init( &lock->condition, NULL ))
{
/* cleanup */
pthread_mutex_destroy( &lock->mutex );
_ump_osu_free( lock );
return NULL;
}
lock->state = UMP_FALSE; /* mark as unlocked by default */
}
lock->flags = flags;
/** Debug lock checking */
UMP_DEBUG_CODE( lock->locked_as = _UMP_OSU_LOCKMODE_UNDEF );
return lock;
}
