Mutex.h

Go to the documentation of this file.

#ifndef INCLUDE_DISTORTOS_C_API_MUTEX_H_
#define INCLUDE_DISTORTOS_C_API_MUTEX_H_

#include "estd/C-API/IntrusiveList.h"

#include <stdint.h>

#ifdef __cplusplus
extern "C"
{
#endif  /* def __cplusplus */

/*---------------------------------------------------------------------------------------------------------------------+
| global types
+---------------------------------------------------------------------------------------------------------------------*/

struct distortos_Mutex
{
    struct estd_IntrusiveListNode node;

    struct estd_IntrusiveList blockedList;

    void* owner;

    uint16_t recursiveLocksCount;

    uint8_t priorityCeiling;

    uint8_t typeProtocol;
};

/*---------------------------------------------------------------------------------------------------------------------+
| global constants
+---------------------------------------------------------------------------------------------------------------------*/

enum
{
    distortos_Mutex_Protocol_none,
    distortos_Mutex_Protocol_priorityInheritance,
    distortos_Mutex_Protocol_priorityProtect
};

enum
{
    distortos_Mutex_Type_normal,
    distortos_Mutex_Type_errorChecking,
    distortos_Mutex_Type_recursive
};

enum
{
    distortos_Mutex_typeShift = 0
};

enum
{
    distortos_Mutex_protocolShift = 4
};

/*---------------------------------------------------------------------------------------------------------------------+
| global defines
+---------------------------------------------------------------------------------------------------------------------*/

#define DISTORTOS_MUTEX_INITIALIZER(self, type, protocol, priorityCeiling) \
        {ESTD_INTRUSIVELISTNODE_INITIALIZER((self).node), ESTD_INTRUSIVELIST_INITIALIZER((self).blockedList), \
        NULL, 0, (priorityCeiling), \
        (uint8_t)(((type) == distortos_Mutex_Type_normal || (type) == distortos_Mutex_Type_errorChecking || \
                (type) == distortos_Mutex_Type_recursive ? \
                (uint8_t)(type) : (uint8_t)distortos_Mutex_Type_normal) << distortos_Mutex_typeShift | \
        ((protocol) == distortos_Mutex_Protocol_none || (protocol) == distortos_Mutex_Protocol_priorityInheritance || \
                (protocol) == distortos_Mutex_Protocol_priorityProtect ? \
                (uint8_t)(protocol) : (uint8_t)distortos_Mutex_Protocol_none) << distortos_Mutex_protocolShift)}

#define DISTORTOS_MUTEX_CONSTRUCT_3(name, type, protocol, priorityCeiling) \
        struct distortos_Mutex name = DISTORTOS_MUTEX_INITIALIZER(name, type, protocol, priorityCeiling)

#define DISTORTOS_MUTEX_CONSTRUCT_2PC(name, protocol, priorityCeiling) \
        DISTORTOS_MUTEX_CONSTRUCT_3(name, distortos_Mutex_Type_normal, protocol, priorityCeiling)

#define DISTORTOS_MUTEX_CONSTRUCT_2TP(name, type, protocol) \
        DISTORTOS_MUTEX_CONSTRUCT_3(name, type, protocol, 0)

#define DISTORTOS_MUTEX_CONSTRUCT_1P(name, protocol) \
        DISTORTOS_MUTEX_CONSTRUCT_3(name, distortos_Mutex_Type_normal, protocol, 0)

#define DISTORTOS_MUTEX_CONSTRUCT_1T(name, type) \
        DISTORTOS_MUTEX_CONSTRUCT_3(name, type, distortos_Mutex_Protocol_none, 0)

#define DISTORTOS_MUTEX_CONSTRUCT(name) \
        DISTORTOS_MUTEX_CONSTRUCT_3(name, distortos_Mutex_Type_normal, distortos_Mutex_Protocol_none, 0)

/*---------------------------------------------------------------------------------------------------------------------+
| global functions
+---------------------------------------------------------------------------------------------------------------------*/

int distortos_Mutex_construct_3(struct distortos_Mutex* mutex, uint8_t type, uint8_t protocol, uint8_t priorityCeiling);

static inline int distortos_Mutex_construct_2pc(struct distortos_Mutex* const mutex, const uint8_t protocol,
        const uint8_t priorityCeiling)
{
    return distortos_Mutex_construct_3(mutex, distortos_Mutex_Type_normal, protocol, priorityCeiling);
}

static inline int distortos_Mutex_construct_2tp(struct distortos_Mutex* const mutex, const uint8_t type,
        const uint8_t protocol)
{
    return distortos_Mutex_construct_3(mutex, type, protocol, 0);
}

static inline int distortos_Mutex_construct_1p(struct distortos_Mutex* const mutex, const uint8_t protocol)
{
    return distortos_Mutex_construct_3(mutex, distortos_Mutex_Type_normal, protocol, 0);
}

static inline int distortos_Mutex_construct_1t(struct distortos_Mutex* const mutex, const uint8_t type)
{
    return distortos_Mutex_construct_3(mutex, type, distortos_Mutex_Protocol_none, 0);
}

static inline int distortos_Mutex_construct(struct distortos_Mutex* const mutex)
{
    return distortos_Mutex_construct_3(mutex, distortos_Mutex_Type_normal, distortos_Mutex_Protocol_none, 0);
}

int distortos_Mutex_destruct(struct distortos_Mutex* mutex);

int distortos_Mutex_lock(struct distortos_Mutex* mutex);

int distortos_Mutex_tryLock(struct distortos_Mutex* mutex);

int distortos_Mutex_tryLockFor(struct distortos_Mutex* mutex, int64_t duration);

int distortos_Mutex_tryLockUntil(struct distortos_Mutex* mutex, int64_t timePoint);

int distortos_Mutex_unlock(struct distortos_Mutex* mutex);

#ifdef __cplusplus
}   /* extern "C" */
#endif  /* def __cplusplus */

#endif  /* INCLUDE_DISTORTOS_C_API_MUTEX_H_ */