1
0
mirror of https://gitlab.os-k.eu/os-k-team/os-k.git synced 2023-08-25 14:03:10 +02:00
os-k/kaleid/include/extras/locks.h
2019-03-19 13:37:23 +01:00

185 lines
4.6 KiB
C

//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: Locks and synchronization //
// //
// //
// Copyright © 2018-2019 The OS/K Team //
// //
// This file is part of OS/K. //
// //
// OS/K 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 3 of the License, or //
// any later version. //
// //
// OS/K 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 OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#ifndef _KALBASE_H
#include <kalbase.h>
#endif
#ifdef _KALEID_KERNEL
#ifndef _KALKERN_PANIC_H
#include <kernel/panic.h>
#endif
#endif
#ifndef _KALEXTRAS_LOCKS_H
#define _KALEXTRAS_LOCKS_H
#ifdef __cplusplus
extern "C" {
#endif
typedef enum LockType_t LockType_t;
typedef struct Lock_t Lock_t;
//------------------------------------------//
enum LockType_t
{
// Mutex-type lock
//
// WARNING
// AcquireLock() panics when used on a mutex while not running a process
KLOCK_MUTEX,
// Spinlock-type lock
KLOCK_SPINLOCK,
};
struct Lock_t
{
unsigned int initDone;
LockType_t type;
volatile int locked;
/* #ifdef _KALEID_KERNEL
Thread_t *ownerThread; // unused
Thread_t *waitingThread; // unused
#endif */
};
//------------------------------------------//
//
// Linux syscall vs unimplemented syscall...
//
#ifndef _KALEID_KERNEL
#ifdef _OSK_SOURCE
int KalYieldCPU(void),
#else
int sched_yield(void);
#endif
#endif
//
// Initialize a lock
//
static inline
void InitLock(Lock_t *lock, LockType_t type)
{
lock->type = type;
lock->locked = FALSE;
lock->initDone = INITOK;
/* #ifdef _KALEID_KERNEL
lock->ownerThread = NULL;
lock->waitingThread = NULL;
#endif */
}
//
// Alternative way to initalize a lock
//
#ifdef _KALEID_KERNEL
# define INITLOCK(type) { INITOK, FALSE, (type), /* NULL, NULL */ }
#else
# define INITLOCK(type) { INITOK, FALSE, (type) }
#endif
//
// Destroy a lock
//
static inline
void DestroyLock(Lock_t *lock)
{
KalAssert(lock->initDone);
__sync_synchronize();
lock->initDone = 0;
}
//
// Acquire the lock
// Panic on double acquisition since that should never happen
// until we have at least a basic scheduler
//
static inline
void AcquireLock(Lock_t *lock)
{
KalAssert(lock->initDone == INITOK);
while (!__sync_bool_compare_and_swap(&lock->locked, 0, 1)) {
#ifdef _KALEID_KERNEL
StartPanic("AcquireLock on an already locked object");
#else
if likely (lock->type == KLOCK_SPINLOCK) continue;
#ifdef _OSK_SOURCE
else (void)KalYieldCPU();
#else
else (void)sched_yield();
#endif
#endif
}
__sync_synchronize();
}
//
// Release an already acquired lock
// Panic if the lock was never acquired
//
static inline
void ReleaseLock(Lock_t *lock)
{
/*#ifdef _KALEID_KERNEL
KalAssert(lock->ownerThread == GetCurThread());
#endif*/
__sync_synchronize();
lock->locked = 0;
}
//
// Tries to acquire lock
//
static inline
bool AttemptLock(Lock_t *lock)
{
KalAssert(lock->initDone == INITOK);
bool retval = __sync_bool_compare_and_swap(&lock->locked, 0, 1);
__sync_synchronize();
return retval;
}
//------------------------------------------//
#ifdef __cplusplus
}
#endif
#endif