First some comments on your code. pthread_mutexattr_t is an opaque type. I really do not think it is a good idea to ever use memset() on an opaque type. It can lead to all sorts on interesting problems.
It looks like you are attempting to port MS Windows code to GNU/Linux. Unfortunately there is no direct equivalant for WaitForSingleObject in GNU/Linux. Sometimes you should use pthread_mutex_lock and other times you will need to use pthread_mutex_trylock. And sometimes you will need to use pthread condition variables. It all depends on the particular applicationi you are porting. Incidently WaitForMultipleObjects is an even bigger nightmare to code around when porting applications to GNU/Linux..
Below is some sample code to try. It contains rough implementations of CreateMutex and ReleaseMutex as well at their Nt*Mutant equivalants. If this sample code works, feel free to use the relevant parts. I suspect your use of memset on opaque types is part of the problem you are having. I have not supplied porting.h but it looks like you have an equivalent header. Basicly it maps MS Windows types to their equivalant GNU/Linux types i.e. PLONG to int32_t *, etc.
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include "porting.h"
/* ---------- mutexes ----------- */
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2;
pthread_mutex_t mutex3;
pthread_mutex_t mutex4;
pthread_mutex_t mutex5;
NTSTATUS
NtCreateMutant( IN pthread_mutex_t *mutex,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
IN BOOLEAN InitialOwner )
{
pthread_mutexattr_t attr;
int rc;
/* NT mutexes are recursive */
pthread_mutexattr_init( &attr );
pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE_NP );
rc = pthread_mutex_init( mutex, &attr );
if ( rc != 0 ) {
fprintf(stderr, "NTCREATEMUTANT pthread_mutex_init failed\n");
}
pthread_mutexattr_destroy(&attr);
return (rc);
}
NTSTATUS
NtReleaseMutant( IN pthread_mutex_t mutex,
OUT PLONG PreviousCount OPTIONAL )
{
int rc;
rc = pthread_mutex_unlock( &mutex );
if ( rc != 0 ) {
fprintf(stderr, "NTRELEASEMUTANT pthread_mutex_unlock failed\n");
}
return (rc);
}
PVOID
CreateMutex( IN PVOID mutex,
IN BOOL InitialOwner,
IN LPCTSTR Name OPTIONAL )
{
pthread_mutexattr_t attr;
int rc;
/* NT mutexes are recursive */
pthread_mutexattr_init( &attr );
pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE_NP );
rc = pthread_mutex_init( (pthread_mutex_t *)mutex, &attr );
if ( rc != 0 ) {
fprintf(stderr, "CREATEMUTEX pthread_mutex_init failed\n");
pthread_mutexattr_destroy(&attr);
return (NULL);
}
pthread_mutexattr_destroy(&attr);
return ( mutex );
}
int
ReleaseMutex( IN pthread_mutex_t mutex )
{
int rc;
rc = pthread_mutex_unlock( &mutex );
if (rc != 0 ) {
fprintf(stderr, "RELEASEMUTEX pthread_mutex_unlock failed\n");
}
return (rc);
}
int
main( int argc,
char *argv[] )
{
pthread_mutexattr_t attr;
pthread_mutex_t *mp;
NTSTATUS Status;
int rc = 0;
pthread_mutexattr_init( &attr );
pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE_NP );
printf("Creating all mutexes ......\n");
printf("mutex1 created by PTHREAD_MUTEX_INITIALIZER\n");
printf("mutex2 created by pthread_mutex_init without attributes object\n");
rc = pthread_mutex_init( &mutex2, NULL );
if (rc != 0 ) {
fprintf(stderr, "pthread_mutex_init NULL\n");
}
printf("mutex3 created by pthread_mutex_init using attributes object\n");
rc = pthread_mutex_init( &mutex3, &attr );
if (rc != 0 ) {
fprintf(stderr, "pthread_mutex_init ATTR\n");
exit(2);
}
pthread_mutexattr_destroy(&attr);
printf("mutex4 created using NtCreateMutant\n");
Status = NtCreateMutant( &mutex4, 0, NULL, 0 );
if (Status != 0 ) {
fprintf(stderr, "NtCreateMutant failed\n");
exit(3);
}
printf("mutex5 created using CreateMutex\n");
mp = CreateMutex( (void *) &mutex5, 0, NULL );
if ( mp == (pthread_mutex_t *) NULL ) {
fprintf(stderr, "CreateMutex failed\n");
exit(4);
}
printf("Locking all mutexes using pthread_mutex_lock\n");
rc = pthread_mutex_lock( &mutex1 );
if (rc != 0 ) {
fprintf(stderr, "pthread_mutex_lock failed\n");
exit(5);
}
rc = pthread_mutex_lock( &mutex2 );
if (rc != 0 ) {
fprintf(stderr, "pthread_mutex_lock failed\n");
exit(6);
}
rc = pthread_mutex_lock( &mutex3 );
if (rc != 0 ) {
fprintf(stderr, "pthread_mutex_lock failed\n");
exit(7);
}
rc = pthread_mutex_lock( &mutex4 );
if (rc != 0 ) {
fprintf(stderr, "pthread_mutex_lock failed\n");
exit(8);
}
rc = pthread_mutex_lock( &mutex5 );
if (rc != 0 ) {
fprintf(stderr, "pthread_mutex_lock failed\n");
exit(9);
}
printf("Unlocking all mutexes ..... \n");
rc = pthread_mutex_unlock( &mutex1 );
if (rc != 0 ) {
fprintf(stderr, "pthread_mutex_unlock failed\n");
exit(10);
}
fprintf(stderr, "mutex1 unlocked using pthread_mutex_unlock\n");
rc = pthread_mutex_unlock( &mutex2 );
if (rc != 0 ) {
fprintf(stderr, "pthread_mutex_unlock failed\n");
exit(11);
}
fprintf(stderr, "mutex2 unlocked using pthread_mutex_unlock\n");
rc = pthread_mutex_unlock( &mutex3 );
if (rc != 0 ) {
fprintf(stderr, "pthread_mutex_unlock failed\n");
exit(12);
}
fprintf(stderr, "mutex3 unlocked using pthread_mutex_unlock\n");
Status = NtReleaseMutant( mutex4, NULL );
if (Status != 0 ) {
fprintf(stderr, "NTReleaseMutant failed\n");
exit(13);
}
fprintf(stderr, "mutex4 unlocked using NtReleaseMutant\n");
rc = ReleaseMutex( mutex5 );
if (rc != 0 ) {
fprintf(stderr, "ReleaseMutex failed\n");
exit(14);
}
fprintf(stderr, "mutex5 unlocked using ReleaseMutex\n");
printf("Destroying all mutexes ......\n");
pthread_mutex_destroy( &mutex1 );
pthread_mutex_destroy( &mutex2 );
pthread_mutex_destroy( &mutex3 );
pthread_mutex_destroy( &mutex4 );
pthread_mutex_destroy( &mutex5 );
return 0;
}
exit\(1\);
\}