#include "flexthread.h"
#include "util.h"

#include <pthread.h>


struct flexthread_mutex * flexthread_mutex_create(void)
{
	struct flexthread_mutex * ftm = 
		xmalloc( sizeof( struct flexthread_mutex ) );

	FATAL_UNLESS( 0 == pthread_mutex_init( &ftm->mutex, NULL ),
			"Mutex initialisation failed" );
	return ftm;

}


void flexthread_mutex_destroy( struct flexthread_mutex * ftm )
{
	NULLCHECK( ftm );

	if( flexthread_mutex_held( ftm ) ) {
		flexthread_mutex_unlock( ftm );
	}
	else if ( (pthread_t)NULL != ftm->holder ) {
		/* This "should never happen": if we can try to destroy
		 * a mutex currently held by another thread, there's a
		 * logic bug somewhere.  I know the test here is racy,
		 * but there's not a lot we can do about it at this
		 * point.
		 */
		fatal( "Attempted to destroy a flexthread_mutex"\
				" held by another thread!" );
	}

	FATAL_UNLESS( 0 == pthread_mutex_destroy( &ftm->mutex ),
			"Mutex destroy failed" );
	free( ftm );
}


int flexthread_mutex_lock( struct flexthread_mutex * ftm )
{
	NULLCHECK( ftm );

	int failure = pthread_mutex_lock( &ftm->mutex );
	if ( 0 == failure ) {
		ftm->holder = pthread_self();
	}

	return failure;
}


int flexthread_mutex_unlock( struct flexthread_mutex * ftm )
{
	NULLCHECK( ftm );

	pthread_t orig = ftm->holder;
	ftm->holder = (pthread_t)NULL;
	int failure = pthread_mutex_unlock( &ftm->mutex );
	if ( 0 != failure ) {
		ftm->holder = orig;
	}
	return failure;
}


int flexthread_mutex_held( struct flexthread_mutex * ftm )
{
	NULLCHECK( ftm );
	return pthread_self() == ftm->holder;
}