sos-code-article10/sos/ksynch.c

257 lines
5.9 KiB
C
Raw Normal View History

2018-07-13 17:13:10 +02:00
/* Copyright (C) 2004 David Decotigny
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
USA.
*/
#include <hwcore/irq.h>
#include <sos/assert.h>
#include "ksynch.h"
sos_ret_t sos_ksema_init(struct sos_ksema *sema, const char *name,
int initial_value,
sos_kwaitq_ordering_t ordering)
{
sema->value = initial_value;
return sos_kwaitq_init(& sema->kwaitq, name, ordering);
}
sos_ret_t sos_ksema_dispose(struct sos_ksema *sema)
{
return sos_kwaitq_dispose(& sema->kwaitq);
}
sos_ret_t sos_ksema_down(struct sos_ksema *sema,
struct sos_time *timeout)
{
sos_ui32_t flags;
sos_ret_t retval;
sos_disable_IRQs(flags);
retval = SOS_OK;
sema->value --;
if (sema->value < 0)
{
/* Wait for somebody to wake us */
retval = sos_kwaitq_wait(& sema->kwaitq, timeout);
/* Something wrong happened (timeout, external wakeup, ...) ? */
if (SOS_OK != retval)
{
/* Yes: pretend we did not ask for the semaphore */
sema->value ++;
}
}
sos_restore_IRQs(flags);
return retval;
}
sos_ret_t sos_ksema_trydown(struct sos_ksema *sema)
{
sos_ui32_t flags;
sos_ret_t retval;
sos_disable_IRQs(flags);
/* Can we take the semaphore without blocking ? */
if (sema->value >= 1)
{
/* Yes: we take it now */
sema->value --;
retval = SOS_OK;
}
else
{
/* No: we signal it */
retval = -SOS_EBUSY;
}
sos_restore_IRQs(flags);
return retval;
}
sos_ret_t sos_ksema_up(struct sos_ksema *sema)
{
sos_ui32_t flags;
sos_ret_t retval;
sos_disable_IRQs(flags);
sema->value ++;
retval = sos_kwaitq_wakeup(& sema->kwaitq, 1, SOS_OK);
sos_restore_IRQs(flags);
return retval;
}
sos_ret_t sos_kmutex_init(struct sos_kmutex *mutex, const char *name,
sos_kwaitq_ordering_t ordering)
{
mutex->owner = NULL;
return sos_kwaitq_init(& mutex->kwaitq, name, ordering);
}
sos_ret_t sos_kmutex_dispose(struct sos_kmutex *mutex)
{
return sos_kwaitq_dispose(& mutex->kwaitq);
}
/*
* Implementation based on ownership transfer (ie no while()
* loop). The only assumption is that the thread awoken by
* kmutex_unlock is not suppressed before effectively waking up: in
* that case the mutex will be forever locked AND unlockable (by
* nobody other than the owner, but this is not natural since this
* owner already issued an unlock()...). The same problem happens with
* the semaphores, but in a less obvious manner.
*/
sos_ret_t sos_kmutex_lock(struct sos_kmutex *mutex,
struct sos_time *timeout)
{
__label__ exit_kmutex_lock;
sos_ui32_t flags;
sos_ret_t retval;
sos_disable_IRQs(flags);
retval = SOS_OK;
/* Mutex already owned ? */
if (NULL != mutex->owner)
{
/* Owned by us or by someone else ? */
if (sos_thread_get_current() == mutex->owner)
{
/* Owned by us: do nothing */
retval = -SOS_EBUSY;
goto exit_kmutex_lock;
}
/* Wait for somebody to wake us */
retval = sos_kwaitq_wait(& mutex->kwaitq, timeout);
/* Something wrong happened ? */
if (SOS_OK != retval)
{
goto exit_kmutex_lock;
}
}
/* Ok, the mutex is available to us: take it */
mutex->owner = sos_thread_get_current();
exit_kmutex_lock:
sos_restore_IRQs(flags);
return retval;
}
sos_bool_t sos_kmutex_owned_by_me(struct sos_kmutex const* mutex)
{
sos_ui32_t flags;
sos_bool_t retval;
sos_disable_IRQs(flags);
retval = (sos_thread_get_current() == mutex->owner);
sos_restore_IRQs(flags);
return retval;
}
sos_ret_t sos_kmutex_trylock(struct sos_kmutex *mutex)
{
sos_ui32_t flags;
sos_ret_t retval;
sos_disable_IRQs(flags);
/* Mutex available to us ? */
if (NULL == mutex->owner)
{
/* Great ! Take it now */
mutex->owner = sos_thread_get_current();
retval = SOS_OK;
}
else
{
/* No: signal it */
retval = -SOS_EBUSY;
}
sos_restore_IRQs(flags);
return retval;
}
sos_ret_t sos_kmutex_unlock(struct sos_kmutex *mutex)
{
sos_ui32_t flags;
sos_ret_t retval;
sos_disable_IRQs(flags);
if (sos_thread_get_current() != mutex->owner)
retval = -SOS_EPERM;
else if (sos_kwaitq_is_empty(& mutex->kwaitq))
{
/*
* There is NOT ANY thread waiting => we really mark the mutex
* as FREE
*/
mutex->owner = NULL;
retval = SOS_OK;
}
else
{
/*
* There is at least 1 thread waiting => we DO NOT mark the
* mutex as free !
* Actually, we should have written:
* mutex->owner = thread_that_is_woken_up;
* But the real Id of the next thread owning the mutex is not
* that important. What is important here is that mutex->owner
* IS NOT NULL and does not correspond to any existing thread
* (address 0x43 is a good candidate because, in SOS, addresses
* below 4kB are never mapped in order to catch invalid
* pointers). Otherwise there will be a possibility for the
* thread woken up here to have the mutex stolen by a thread
* locking the mutex in the meantime.
*/
#define MUTEX_STILL_LOCKED ((struct sos_thread*) 0x43)
mutex->owner = MUTEX_STILL_LOCKED;
/* We wake up ONE thread ONLY */
retval = sos_kwaitq_wakeup(& mutex->kwaitq, 1, SOS_OK);
}
sos_restore_IRQs(flags);
return retval;
}