lock.c

Go to the documentation of this file.

/***************************************************************************
 * lock.c
 * (C) 2010 Ivan Meleca
 * Based on original code written by Ruben Meleca
 * www.milos.it

#   This program is free software; you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation; either version 2 of the License, or
#   (at your option) any later version.
#
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#
#   You should have received a copy of the GNU General Public License
#   along with this program; if not, write to the Free Software
#   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

***************************************************************************/

#include "lock.h"
#include "heap.h"
#include "dbgterm.h"
#include <common/common.h>
#include <core/system.h>

u8 __lockCount = 0; 
__PLOCK_LIST __lockList = __NULL;   
__PLOCK __lockCreate(__VOID)
{
__PLOCK         lock;
__PLOCK_LIST    list;
__PLOCK_LIST    list_root = __NULL;

    __systemStop();

    /* Alloc and assign */
    lock = __heapAlloc(sizeof(__LOCK));
    if (!lock)
    {
        __systemStart();
        return __NULL;
    }

    lock->state     = __LOCK_RELEASED;
    lock->type      = __LOCK_TYPE_NORMAL;
    lock->owner     = __NULL;
    lock->parent    = __threadGetCurrent();
    
    /* Add to list */
    list = __lockList;
    while(list != __NULL)
    {
        /* Remember last list */
        list_root = list;
        list = list->next;
    }

    list = __heapAllocZero(sizeof(__LOCK_LIST));
    if (!list)
    {
        __heapFree(lock);
        __systemStart();
        return __NULL;
    }

    list->lock = lock;
    list->next = __NULL;

    if (__lockList == __NULL)
    {
        __lockList = list;
    } else
    {
        list_root->next = list;
    }

    __lockCount++;

    __systemStart();

    return lock;
}

__STATIC u8 __lockWait(__PLOCK lock, u32 wait)
{
    u8 ret = __EVRET_TIMEOUT;

    __eventReset(&lock->event);
    ret = __eventWait(&lock->event, wait);
    return ret;
}

__BOOL  __lockOwn(__PLOCK lock, u32 wait)
{
    u32 time = 0;

    __systemStop();

    /* Check if __lockOwn is not being called from an already
     * "owner" thread.
     */
    if (lock->state == __LOCK_LOCKED && lock->owner == __threadGetCurrent()) {
        __systemStart();
        return __TRUE;
    }

    /* Here, in the case of a failed lock wait, we will
     * reuse the time left to wait again.
     * For example can happen that:
     *
     * 1-   Thread1 and Thread2 has the same priority, so they won't preempt
     *      each other.
     * 2-   Thread1 owns a lock, and goes suspended.
     * 3-   Thread2 wants to own the locked lock, but the lock
     *      is busy, so it will enter __lockWait().
     * 4-   Thread1 wakes up, and releases the lock (__lockRelease()),
     *      setting Thread2 ready to run. But soon after releasing, Thread1 owns the lock again,
     *      and goes suspended.
     * 5-   Thread2, waked up and ready to run by the __lockRelease() call (from Thread1)
     *      tries to own the lock, but it founds it locked.
     *
     */
    time = wait;
    while (lock->state != __LOCK_RELEASED && time)
    {
        __lockWait(lock, time);
        time = __threadGetCurrent()->th_wait;
    }

    if (lock->state != __LOCK_RELEASED)
    {
        __systemStart();
        return __FALSE;
    }

    lock->state = __LOCK_LOCKED;
    lock->owner = __threadGetCurrent();

    __systemStart();
    return __TRUE;
}

__BOOL  __lockRelease(__PLOCK lock)
{
    if (!lock) return __FALSE;

    __systemStop();
    lock->state = __LOCK_RELEASED;
    lock->owner = __NULL;
    
    /* wake threads waiting for this lock */
    __eventSetOne(&lock->event);
    __systemStart();

    return __TRUE;
}

__VOID  __lockDestroy(__PLOCK lock)
{
__PLOCK_LIST list       = __NULL;
__PLOCK_LIST root_list  = __NULL;

    list = __lockList;
    root_list = list;

    __systemStop();
    while (list)
    {
        if (list->lock == lock)
        {
            __heapFree(lock);

            if (__lockList == list)
            {
                (list->next != __NULL) ? (__lockList = list->next) : (__lockList = __NULL);
            } else
            {
                (list->next != __NULL) ? (root_list->next = list->next) : (root_list->next = __NULL);
            }

            __heapFree(list);

            __lockCount--;

            __systemStart();
            return;
        }

        root_list = list;
        list = list->next;
    }
    __systemStart();
    return;
}

u32 __lockGetCount(__VOID)
{
    return __lockCount;
}

__PLOCK_LIST __lockGetList(__VOID)
{
    return __lockList;
}