/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/**
 ************************************************************************
 * @brief        Mutex for Android
 * @note         This file implements functions to manipulate mutex
 ************************************************************************
*/

#include "M4OSA_Debug.h"
#include "M4OSA_Types.h"
#include "M4OSA_Error.h"
#include "M4OSA_Memory.h"
#include "M4OSA_Mutex.h"

#include <pthread.h>
#include <errno.h>


/* Context for the mutex */
typedef struct
{
   M4OSA_UInt32     coreID;               /* mutex context identifiant */
   pthread_mutex_t  mutex;                /* mutex */
   pthread_t        threadOwnerID;        /* thread owner identifiant */
} M4OSA_MutexContext;


/**
 ************************************************************************
 * @brief      This method creates a new mutex.
 * @note       This function creates and allocates a unique context. It's the
 *             OSAL real time responsibility for managing its context. It must
 *             be freed by the M4OSA_mutexClose function. The context parameter
 *             will be sent back to any OSAL core mutex functions to allow
 *             retrieving data associated to the opened mutex.
 * @param      pContext:(OUT) Context of the created mutex
 * @return     M4NO_ERROR: there is no error
 * @return     M4ERR_ALLOC: there is no more available memory
 * @return     M4ERR_CONTEXT_FAILED: the context creation failed
 ************************************************************************
*/
M4OSA_ERR M4OSA_mutexOpen(M4OSA_Context* pContext)
{
    M4OSA_MutexContext* pMutexContext = (M4OSA_MutexContext*)M4OSA_NULL;
    pthread_mutexattr_t attribute = { 0 };
    M4OSA_Bool opened = M4OSA_FALSE;

    M4OSA_TRACE1_1("M4OSA_mutexOpen\t\tM4OSA_Context* 0x%x", pContext);
    M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER,
                                     "M4OSA_mutexOpen: pContext is M4OSA_NULL");

    *pContext = M4OSA_NULL;

    pMutexContext = (M4OSA_MutexContext*)M4OSA_32bitAlignedMalloc(sizeof(M4OSA_MutexContext),
                    M4OSA_MUTEX, (M4OSA_Char*)"M4OSA_mutexOpen: mutex context");

    if(M4OSA_NULL == pMutexContext)
    {
        M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_mutexOpen");
        return M4ERR_ALLOC;
    }

    /* Initialize the mutex attribute. */
    if ( 0 == pthread_mutexattr_init( &attribute ) )
    {
        /* Initialize the mutex type. */
        if ( 0 == pthread_mutexattr_settype( &attribute, PTHREAD_MUTEX_RECURSIVE ) )
        {
            /* Initialize the mutex. */
            if (0 == pthread_mutex_init( &pMutexContext->mutex, &attribute ) )
            {
                opened = M4OSA_TRUE;
            }
        }

        /* Destroy the mutex attribute. */
        pthread_mutexattr_destroy( &attribute );
    }

    if(!opened)
    {
        M4OSA_DEBUG(M4ERR_CONTEXT_FAILED, "M4OSA_mutexOpen: OS mutex creation failed");
        free(pMutexContext);
        return M4ERR_CONTEXT_FAILED ;
    }

    pMutexContext->coreID = M4OSA_MUTEX;

    pMutexContext->threadOwnerID = 0;

    *pContext = (M4OSA_Context) pMutexContext;

    return M4NO_ERROR;
}


/**
 ************************************************************************
 * @brief      This method locks the mutex. "Context" identifies the mutex.
 * @note       If the mutex is already locked, the calling thread blocks until
 *             the mutex becomes available (by calling M4OSA_mutexUnlock) or
 *             "timeout" is reached. This is a blocking call.
 * @param      context:(IN/OUT) Context of the mutex
 * @param      timeout:(IN) Time out in milliseconds
 * @return     M4NO_ERROR: there is no error
 * @return     M4ERR_PARAMETER: at least one parameter is NULL
 * @return     M4WAR_TIME_OUT: time out is elapsed before mutex has been
 *             available
 * @return     M4ERR_BAD_CONTEXT: provided context is not a valid one
 ************************************************************************
*/
M4OSA_ERR M4OSA_mutexLock(M4OSA_Context context, M4OSA_UInt32 timeout)
{
    M4OSA_MutexContext* pMutexContext = (M4OSA_MutexContext*)context;
    pthread_t           currentThread;
    int                 result;
    struct timespec     ts;
    struct timespec     left;

    M4OSA_TRACE1_2("M4OSA_mutexLock\t\tM4OSA_Context 0x%x\tM4OSA_UInt32 %d",
        context, timeout);

    M4OSA_DEBUG_IF2(M4OSA_NULL == context, M4ERR_PARAMETER,
                                      "M4OSA_mutexLock: context is M4OSA_NULL");
    M4OSA_DEBUG_IF2(pMutexContext->coreID != M4OSA_MUTEX,
                                          M4ERR_BAD_CONTEXT, "M4OSA_mutexLock");

    currentThread = pthread_self();

    if(pMutexContext ->threadOwnerID == currentThread)
    {
        M4OSA_DEBUG(M4ERR_BAD_CONTEXT, "M4OSA_mutexLock: Thread tried to lock a mutex it already owns");
        return M4ERR_BAD_CONTEXT ;
    }

    /* Lock the mutex. */
    if ( M4OSA_WAIT_FOREVER == timeout)
    {
        if ( 0 != pthread_mutex_lock(&pMutexContext->mutex) )
        {
            M4OSA_DEBUG(M4ERR_BAD_CONTEXT, "M4OSA_mutexLock: OS mutex wait failed");
            return M4ERR_BAD_CONTEXT;
        }
    }
    else
    {
        result = pthread_mutex_trylock(&pMutexContext->mutex);
        while ( ( EBUSY == result ) && ( 0 < timeout ) )
        {
            ts.tv_sec  = 0;
            if (1 <= timeout)
            {
                ts.tv_nsec = 1000000;
                timeout -= 1;
            }
            else
            {
                ts.tv_nsec = timeout * 1000000;
                timeout = 0;
            }
            nanosleep(&ts, &left);
            result = pthread_mutex_trylock(&pMutexContext->mutex);
        }
        if (0 != result)
        {
            if (EBUSY == result)
            {
                return M4WAR_TIME_OUT;
            }
            else
            {
                M4OSA_DEBUG(M4ERR_BAD_CONTEXT, "M4OSA_mutexLock: OS mutex wait failed");
                return M4ERR_BAD_CONTEXT;
            }
        }
    }

    pMutexContext->threadOwnerID = currentThread;

    return M4NO_ERROR;
}


/**
 ************************************************************************
 * @brief      This method unlocks the mutex. The mutex is identified by
 *             its context
 * @note       The M4OSA_mutexLock unblocks the thread with the highest
 *             priority and made it ready to run.
 * @note       No hypotheses can be made on which thread will be un-blocked
 *             between threads with the same priority.
 * @param      context:(IN/OUT) Context of the mutex
 * @return     M4NO_ERROR: there is no error
 * @return     M4ERR_PARAMETER: at least one parameter is NULL
 * @return     M4ERR_BAD_CONTEXT: provided context is not a valid one
************************************************************************
*/
M4OSA_ERR M4OSA_mutexUnlock(M4OSA_Context context)
{
    M4OSA_MutexContext* pMutexContext = (M4OSA_MutexContext*)context;
    pthread_t currentThread;

    M4OSA_TRACE1_1("M4OSA_mutexUnlock\t\tM4OSA_Context 0x%x", context);
    M4OSA_DEBUG_IF2(M4OSA_NULL == context, M4ERR_PARAMETER,
                                    "M4OSA_mutexUnlock: context is M4OSA_NULL");
    M4OSA_DEBUG_IF2(M4OSA_MUTEX != pMutexContext->coreID,
                                        M4ERR_BAD_CONTEXT, "M4OSA_mutexUnlock");

    currentThread = pthread_self();

    if(pMutexContext->threadOwnerID != currentThread)
    {
        M4OSA_DEBUG(M4ERR_BAD_CONTEXT, "M4OSA_mutexUnlock: Thread tried to unlock a mutex it doesn't own");
        return M4ERR_BAD_CONTEXT;
    }

    pMutexContext->threadOwnerID = 0 ;

    pthread_mutex_unlock(&pMutexContext->mutex);

    return M4NO_ERROR;
}


/**
 ************************************************************************
 * @brief      This method deletes a mutex (identify by its context). After
 *             this call, the mutex and its context is no more useable. This
 *             function frees all the memory related to this mutex.
 * @note       It is an application issue to warrant no more threads are locked
 *             on the deleted mutex.
 * @param      context:(IN/OUT) Context of the mutex
 * @return     M4NO_ERROR: there is no error
 * @return     M4ERR_PARAMETER: at least one parameter is NULL
 * @return     M4ERR_BAD_CONTEXT: provided context is not a valid one
 ************************************************************************
*/
M4OSA_ERR M4OSA_mutexClose(M4OSA_Context context)
{
    M4OSA_MutexContext* pMutexContext = (M4OSA_MutexContext*)context;

    M4OSA_TRACE1_1("M4OSA_mutexClose\t\tM4OSA_Context 0x%x", context);

    M4OSA_DEBUG_IF2(M4OSA_NULL == context, M4ERR_PARAMETER,
                                     "M4OSA_mutexClose: context is M4OSA_NULL");
    M4OSA_DEBUG_IF2(pMutexContext->coreID != M4OSA_MUTEX,
                                        M4ERR_BAD_CONTEXT, "M4OSA_mutexUnlock");

    pthread_mutex_destroy(&pMutexContext->mutex);

    free( pMutexContext);

    return M4NO_ERROR;
}