osdMutex.c File Reference

#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
#include "epicsMutex.h"
#include "cantProceed.h"
#include "epicsTime.h"
#include "errlog.h"
#include "epicsAssert.h"

Include dependency graph for osdMutex.c:

Go to the source code of this file.

Classes
struct	epicsMutexOSD

Macros
#define	checkStatus(status, message)
#define	checkStatusQuit(status, message, method)

Typedefs
typedef struct epicsMutexOSD	epicsMutexOSD

Functions
epicsMutexOSD *	epicsMutexOsdCreate (void)
void	epicsMutexOsdDestroy (struct epicsMutexOSD *pmutex)
void	epicsMutexOsdUnlock (struct epicsMutexOSD *pmutex)
epicsMutexLockStatus	epicsMutexOsdLock (struct epicsMutexOSD *pmutex)
epicsMutexLockStatus	epicsMutexOsdTryLock (struct epicsMutexOSD *pmutex)
void	epicsMutexOsdShow (struct epicsMutexOSD *pmutex, unsigned int level)

Macro Definition Documentation

#define checkStatus	(		status,
			message
	)

Value:

if((status)) { \
        errlogPrintf("epicsMutex %s failed: error %s\n", \
            (message), strerror((status))); \
    }

Definition at line 29 of file osdMutex.c.

#define checkStatusQuit	(		status,
			message,
			method
	)

Value:

if(status) { \
        errlogPrintf("epicsMutex %s failed: error %s\n", \
            (message), strerror((status))); \
        cantProceed((method)); \
    }

Definition at line 34 of file osdMutex.c.

Typedef Documentation

typedef struct epicsMutexOSD epicsMutexOSD

Function Documentation

epicsMutexOSD* epicsMutexOsdCreate

(

void

)

The following are interfaces to the OS dependent implementation and should NOT be called directly by user code.

Definition at line 175 of file osdMutex.c.

                                          {
    epicsMutexOSD *pmutex;
    int           status;

    pmutex = calloc(1, sizeof(*pmutex));
    if(!pmutex)
        return NULL;

    status = pthread_mutexattr_init(&pmutex->mutexAttr);
    if(status)
        goto fail;

#if defined(_POSIX_THREAD_PRIO_INHERIT) && _POSIX_THREAD_PRIO_INHERIT > 0
    status = pthread_mutexattr_setprotocol(
        &pmutex->mutexAttr,PTHREAD_PRIO_INHERIT);
    if (errVerbose) checkStatus(status, "pthread_mutexattr_setprotocal");
#endif /*_POSIX_THREAD_PRIO_INHERIT*/

    status = pthread_mutex_init(&pmutex->lock, &pmutex->mutexAttr);
    if(status)
        goto dattr;

#if defined(_POSIX_THREAD_PROCESS_SHARED) && _POSIX_THREAD_PROCESS_SHARED > 0
    status = pthread_condattr_init(&pmutex->condAttr);
    checkStatus(status, "pthread_condattr_init");
    status = pthread_condattr_setpshared(&pmutex->condAttr,
        PTHREAD_PROCESS_PRIVATE);
    checkStatus(status, "pthread_condattr_setpshared");
    status = pthread_cond_init(&pmutex->waitToBeOwner, &pmutex->condAttr);
#else
    status = pthread_cond_init(&pmutex->waitToBeOwner, 0);
#endif /*_POSIX_THREAD_PROCESS_SHARED*/
    if(status)
        goto dmutex;

    return pmutex;

dmutex:
    pthread_mutex_destroy(&pmutex->lock);
dattr:
    pthread_mutexattr_destroy(&pmutex->mutexAttr);
fail:
    free(pmutex);
    return NULL;
}

void epicsMutexOsdDestroy

(

struct epicsMutexOSD *

pmutex

)

Definition at line 221 of file osdMutex.c.

{
    int   status;

    status = pthread_cond_destroy(&pmutex->waitToBeOwner);
    checkStatus(status, "pthread_cond_destroy");
#if defined(_POSIX_THREAD_PROCESS_SHARED) && _POSIX_THREAD_PROCESS_SHARED > 0
    status = pthread_condattr_destroy(&pmutex->condAttr);
#endif /*_POSIX_THREAD_PROCESS_SHARED*/
    status = pthread_mutex_destroy(&pmutex->lock);
    checkStatus(status, "pthread_mutex_destroy");
    status = pthread_mutexattr_destroy(&pmutex->mutexAttr);
    checkStatus(status, "pthread_mutexattr_destroy");
    free(pmutex);
}

epicsMutexLockStatus epicsMutexOsdLock

(

struct epicsMutexOSD *

pmutex

)

Definition at line 276 of file osdMutex.c.

{
    pthread_t tid = pthread_self();
    int status;

    if (!pmutex || !tid) return epicsMutexLockError;
    status = mutexLock(&pmutex->lock);
    if (status == EINVAL) return epicsMutexLockError;
    checkStatus(status, "pthread_mutex_lock epicsMutexOsdLock");
    if(status)
        return epicsMutexLockError;

    while (pmutex->owned && !pthread_equal(pmutex->ownerTid, tid))
        condWait(&pmutex->waitToBeOwner, &pmutex->lock);
    pmutex->ownerTid = tid;
    pmutex->owned = 1;
    pmutex->count++;

    status = pthread_mutex_unlock(&pmutex->lock);
    checkStatus(status, "pthread_mutex_unlock epicsMutexOsdLock");
    if(status)
        return epicsMutexLockError;
    return epicsMutexLockOK;
}

void epicsMutexOsdShow	(	struct epicsMutexOSD *	pmutex,
		unsigned int	level
	)

Definition at line 329 of file osdMutex.c.

{
    printf("ownerTid %p count %d owned %d\n",
        (void *)pmutex->ownerTid, pmutex->count, pmutex->owned);
}

epicsMutexLockStatus epicsMutexOsdTryLock

(

struct epicsMutexOSD *

pmutex

)

Definition at line 301 of file osdMutex.c.

{
    pthread_t tid = pthread_self();
    epicsMutexLockStatus result;
    int status;

    status = mutexLock(&pmutex->lock);
    if (status == EINVAL) return epicsMutexLockError;
    checkStatus(status, "pthread_mutex_lock epicsMutexOsdTryLock");
    if(status)
        return epicsMutexLockError;

    if (!pmutex->owned || pthread_equal(pmutex->ownerTid, tid)) {
        pmutex->ownerTid = tid;
        pmutex->owned = 1;
        pmutex->count++;
        result = epicsMutexLockOK;
    } else {
        result = epicsMutexLockTimeout;
    }

    status = pthread_mutex_unlock(&pmutex->lock);
    checkStatus(status, "pthread_mutex_unlock epicsMutexOsdTryLock");
    if(status)
        return epicsMutexLockError;
    return result;
}

void epicsMutexOsdUnlock

(

struct epicsMutexOSD *

pmutex

)

Definition at line 237 of file osdMutex.c.

{
    int status;

    status = mutexLock(&pmutex->lock);
    checkStatus(status, "pthread_mutex_lock epicsMutexOsdUnlock");
    if(status)
        return;

    if ((pmutex->count <= 0) || (pmutex->ownerTid != pthread_self())) {
        pthread_mutex_unlock(&pmutex->lock);
        checkStatus(status, "pthread_mutex_unlock epicsMutexOsdUnlock");
        errlogPrintf("epicsMutexOsdUnlock but caller is not owner\n");
        cantProceed("epicsMutexOsdUnlock but caller is not owner");
        return;
    }

    pmutex->count--;
    if (pmutex->count == 0) {
        pmutex->owned = 0;
        pmutex->ownerTid = 0;
        status = pthread_cond_signal(&pmutex->waitToBeOwner);
        checkStatusQuit(status, "pthread_cond_signal epicsMutexOsdUnlock", "epicsMutexOsdUnlock");
    }

    status = pthread_mutex_unlock(&pmutex->lock);
    checkStatus(status, "pthread_mutex_unlock epicsMutexOsdUnlock");
}