J Reece Wilson
2209aeb7a8
[*] BSD: Rewrote fundamentally flawed pthread_mutex class code to use MONOTONIC clock time [+] Linus SwInfo: Added enterprise check for RedHat
176 lines
4.1 KiB
C++
Executable File
176 lines
4.1 KiB
C++
Executable File
/***
|
|
Copyright (C) 2022 J Reece Wilson (a/k/a "Reece"). All rights reserved.
|
|
|
|
File: AuMutex.Linux.cpp
|
|
Date: 2022-12-28
|
|
Author: Reece
|
|
***/
|
|
#include <Source/RuntimeInternal.hpp>
|
|
#include "AuMutex.Generic.hpp"
|
|
|
|
#include <sys/syscall.h>
|
|
#include <linux/futex.h>
|
|
|
|
#if !defined(_AURUNTIME_GENERIC_MUTEX)
|
|
#include <Source/Time/Time.hpp>
|
|
|
|
namespace Aurora::Threading::Primitives
|
|
{
|
|
static int futex(uint32_t *uaddr, int futex_op, uint32_t val,
|
|
const struct timespec *timeout,
|
|
uint32_t *uaddr2, uint32_t val3)
|
|
{
|
|
return syscall(SYS_futex, uaddr, futex_op, val, timeout, uaddr2, val3);
|
|
}
|
|
|
|
static int futex_wait(uint32_t *addr, uint32_t expected)
|
|
{
|
|
return futex(addr, FUTEX_WAIT, expected, 0, 0, 0);
|
|
}
|
|
|
|
static int futex_wait(uint32_t *addr, uint32_t expected, const struct timespec *timeout)
|
|
{
|
|
if (timeout)
|
|
{
|
|
return futex(addr, FUTEX_WAIT_BITSET, expected, timeout, 0, FUTEX_BITSET_MATCH_ANY);
|
|
}
|
|
else
|
|
{
|
|
return futex(addr, FUTEX_WAIT, expected, timeout, 0, 0);
|
|
}
|
|
}
|
|
|
|
static int futex_wake(uint32_t *addr, uint32_t nthreads)
|
|
{
|
|
return futex(addr, FUTEX_WAKE, nthreads, 0, 0, 0);
|
|
}
|
|
|
|
Mutex::Mutex()
|
|
{
|
|
|
|
}
|
|
|
|
Mutex::~Mutex()
|
|
{
|
|
|
|
}
|
|
|
|
bool Mutex::HasOSHandle(AuMach &mach)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool Mutex::HasLockImplementation()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool Mutex::TryLock()
|
|
{
|
|
auto old = this->value_;
|
|
return (old == 0 && AuAtomicCompareExchange<AuUInt32>(&this->value_, 1, old) == old);
|
|
}
|
|
|
|
bool Mutex::Lock(AuUInt64 uTimeout)
|
|
{
|
|
if (this->TryLock())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
AuUInt64 uStart = AuTime::SteadyClockMS();
|
|
AuUInt64 uEnd = uStart + uTimeout;
|
|
|
|
struct timespec tspec;
|
|
if (uTimeout != 0)
|
|
{
|
|
Time::ms2tsabs(&tspec, uTimeout);
|
|
}
|
|
|
|
auto state = this->value_;
|
|
while (!(state == 0 && AuAtomicCompareExchange<AuUInt32>(&this->value_, 1, state) == state))
|
|
{
|
|
if (uTimeout != 0)
|
|
{
|
|
uStart = Time::SteadyClockMS();
|
|
if (uStart >= uEnd)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int ret {};
|
|
do
|
|
{
|
|
ret = futex_wait(&this->value_, state, &tspec);
|
|
|
|
if (ret == 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (ret == EAGAIN || errno == EAGAIN)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (ret == ETIMEDOUT || errno == ETIMEDOUT)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
while (ret == EINTR);
|
|
|
|
RUNTIME_ASSERT_SHUTDOWN_SAFE(false, "semaphore timed wait failed: {}", ret)
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
int ret {};
|
|
do
|
|
{
|
|
if ((ret = futex_wait(&this->value_, state)) == 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (ret == EAGAIN || errno == EAGAIN)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
}
|
|
while (ret == EINTR);
|
|
|
|
RUNTIME_ASSERT_SHUTDOWN_SAFE(false, "semaphore wait failed: {}", ret)
|
|
return false;
|
|
}
|
|
|
|
state = this->value_;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void Mutex::Lock()
|
|
{
|
|
auto status = Lock(0);
|
|
SysAssert(status, "Couldn't lock mutex");
|
|
}
|
|
|
|
void Mutex::Unlock()
|
|
{
|
|
this->value_ = 0;
|
|
futex_wake(&this->value_, 1);
|
|
}
|
|
|
|
AUKN_SYM IWaitable *MutexNew()
|
|
{
|
|
return _new Mutex();
|
|
}
|
|
|
|
AUKN_SYM void MutexRelease(IWaitable *pMutex)
|
|
{
|
|
AuSafeDelete<Mutex *>(pMutex);
|
|
}
|
|
}
|
|
#endif |