oc_mutex.c

Go to the documentation of this file.

#include <oc_mutex.h>
#include <oc_thread.h>
#include <oc_object.h>
#include <oc_stdlib.h>
#include <oc_thread.h>
#include <oc_intman.h>
#include <oc_threadman.h>
#include <oc_null.h>

#define _________________________________________LOCAL_TYPES_SECTION_______________________________________________________________________

struct Mutex_t
{
    oC_ObjectControl_t      ObjectControl;
    int16_t                 RecursiveCount;
    oC_Mutex_Type_t         Type;
    uint32_t                LockedFlag;
    oC_Thread_t             BlockedThread;
};

#undef  _________________________________________LOCAL_TYPES_SECTION_______________________________________________________________________


#define _________________________________________LOCAL_VARIABLES_SECTION____________________________________________________________________


#undef  _________________________________________LOCAL_VARIABLES_SECTION____________________________________________________________________


#define _________________________________________LOCAL_PROTOTYPES_SECTION___________________________________________________________________

static bool RevertFunction( oC_Thread_t Thread, void * Mutex, uint32_t Parameter );

#undef  _________________________________________LOCAL_PROTOTYPES_SECTION___________________________________________________________________

#define _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
oC_Mutex_t oC_Mutex_New( oC_Mutex_Type_t Type , Allocator_t Allocator , AllocationFlags_t AllocationFlags )
{
    oC_Mutex_t mutex = kmalloc(sizeof(struct Mutex_t), Allocator , AllocationFlags_NoWait);

    if(mutex)
    {
        mutex->LockedFlag        = false;
        mutex->BlockedThread     = NULL;
        mutex->Type              = Type;
        mutex->ObjectControl     = oC_CountObjectControl(mutex,oC_ObjectId_Mutex);
    }

    return mutex;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Mutex_Delete( oC_Mutex_t * Mutex , AllocationFlags_t AllocationFlags )
{
    bool deleted = false;

    if(oC_Mutex_IsCorrect(*Mutex))
    {
        oC_IntMan_EnterCriticalSection();
        (*Mutex)->ObjectControl = 0;
        oC_ThreadMan_UnblockAllBlockedBy(&((*Mutex)->LockedFlag),false);
        if(!kfree(*Mutex,AllocationFlags))
        {
            oC_SaveError("Mutex" , oC_ErrorCode_ReleaseError);
        }
        else
        {
            *Mutex  = NULL;
            deleted = true;
        }
        oC_IntMan_ExitCriticalSection();
    }
    else
    {
        oC_SaveError("Mutex" , oC_ErrorCode_ObjectNotCorrect);
    }

    return deleted;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Mutex_Give( oC_Mutex_t Mutex )
{
    bool given = false;

    if(oC_Mutex_IsCorrect(Mutex))
    {
        if(oC_ThreadMan_GetCurrentThread() == Mutex->BlockedThread)
        {
            oC_IntMan_EnterCriticalSection();
            Mutex->RecursiveCount++;
            if(
                (Mutex->Type == oC_Mutex_Type_Normal) ||
                (Mutex->RecursiveCount >= 0)
                )
            {
                oC_Thread_RemoveFromRevert(getcurthread(),RevertFunction, Mutex);
                Mutex->LockedFlag = false;
            }
            given = true;
            oC_IntMan_ExitCriticalSection();
        }
        else
        {
            oC_SaveError("Mutex" , oC_ErrorCode_WrongThread);
        }
    }
    else
    {
        oC_SaveError("Mutex" , oC_ErrorCode_ObjectNotCorrect);
    }

    return given;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Mutex_Take( oC_Mutex_t Mutex , oC_Time_t Timeout )
{
    bool taken = false;

    if(oC_Mutex_IsCorrect(Mutex))
    {
        oC_Thread_t currentThread = oC_ThreadMan_GetCurrentThread();

        if(Mutex->LockedFlag)
        {
            if(currentThread != Mutex->BlockedThread)
            {
                if( oC_Thread_SetBlocked(currentThread , &Mutex->LockedFlag , oC_Thread_Unblock_WhenEqual , false , oC_Thread_UnblockMask_All , Timeout ) )
                {
                    while(oC_Thread_IsBlocked(currentThread));

                    oC_Thread_SetUnblocked(currentThread);

                    oC_IntMan_EnterCriticalSection();
                    if(oC_Mutex_IsCorrect(Mutex) && (Mutex->LockedFlag == 0))
                    {
                        Mutex->LockedFlag    = true;
                        Mutex->BlockedThread = currentThread;
                        Mutex->RecursiveCount--;
                        taken                = true;

                        oC_Thread_SaveToRevert(currentThread,RevertFunction,Mutex,0);
                    }
                    oC_IntMan_ExitCriticalSection();
                }
            }
            else
            {
                oC_IntMan_EnterCriticalSection();
                Mutex->RecursiveCount--;
                taken                = true;
                oC_IntMan_ExitCriticalSection();
            }
        }
        else
        {
            oC_IntMan_EnterCriticalSection();
            Mutex->LockedFlag    = true;
            Mutex->BlockedThread = currentThread;
            Mutex->RecursiveCount--;
            taken                = true;

            oC_Thread_SaveToRevert(currentThread,RevertFunction,Mutex,0);
            oC_IntMan_ExitCriticalSection();
        }
    }
    else
    {
        oC_SaveError("Mutex" , oC_ErrorCode_ObjectNotCorrect);
    }

    return taken;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Mutex_IsCorrect( oC_Mutex_t Mutex )
{
    return oC_MemMan_IsRamAddress(Mutex) && oC_CheckObjectControl(Mutex , oC_ObjectId_Mutex , Mutex->ObjectControl);
}

#undef  _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________

#define _________________________________________LOCAL_FUNCTIONS_SECTION____________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
static bool RevertFunction( oC_Thread_t Thread, void * Mutex, uint32_t Parameter )
{
    bool        reverted = false;
    oC_Mutex_t  mutex    = Mutex;

    oC_IntMan_EnterCriticalSection();
    if(oC_SaveIfFalse("Mutex", oC_Mutex_IsCorrect(mutex), oC_ErrorCode_ObjectNotCorrect))
    {
        mutex->BlockedThread    = NULL;
        mutex->LockedFlag       = false;
        mutex->RecursiveCount   = 0;
        reverted = true;
    }
    oC_IntMan_ExitCriticalSection();

    return reverted;
}

#undef  _________________________________________LOCAL_FUNCTIONS_SECTION____________________________________________________________________