OmniNX/Atmosphere
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

os: adopt nintendo ReaderWriter naming over ReadWrite

Browse Source
This commit is contained in:
Michael Scire
2021-10-01 11:42:34 -07:00
parent 00d0c94f2d
commit 2b37e5d486
21 changed files with 183 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
libraries/libstratosphere/source/diag/impl/diag_observer_manager.hpp
View File

@@ -25,7 +25,7 @@ namespace ams::diag::impl {
private:
Holder *m_observer_list_head;
Holder **m_observer_list_tail;
os::ReadWriteLock m_lock;
os::ReaderWriterLock m_lock;
public:
constexpr ObserverManager() : m_observer_list_head(nullptr), m_observer_list_tail(std::addressof(m_observer_list_head)), m_lock() {
/* ... */

8
libraries/libstratosphere/source/fssrv/fssrv_filesystem_interface_adapter.cpp
View File

@@ -31,7 +31,7 @@ namespace ams::fssrv::impl {
void FileInterfaceAdapter::InvalidateCache() {
AMS_ABORT_UNLESS(this->parent_filesystem->IsDeepRetryEnabled());
std::scoped_lock<os::ReadWriteLock> scoped_write_lock(this->parent_filesystem->GetReadWriteLockForCacheInvalidation());
std::scoped_lock<os::ReaderWriterLock> scoped_write_lock(this->parent_filesystem->GetReaderWriterLockForCacheInvalidation());
this->base_file->OperateRange(nullptr, 0, fs::OperationId::Invalidate, 0, std::numeric_limits<s64>::max(), nullptr, 0);
}
@@ -154,15 +154,15 @@ namespace ams::fssrv::impl {
AMS_ABORT_UNLESS(false);
}
util::optional<std::shared_lock<os::ReadWriteLock>> FileSystemInterfaceAdapter::AcquireCacheInvalidationReadLock() {
util::optional<std::shared_lock<os::ReadWriteLock>> lock;
util::optional<std::shared_lock<os::ReaderWriterLock>> FileSystemInterfaceAdapter::AcquireCacheInvalidationReadLock() {
util::optional<std::shared_lock<os::ReaderWriterLock>> lock;
if (this->deep_retry_enabled) {
lock.emplace(this->invalidation_lock);
}
return lock;
}
os::ReadWriteLock &FileSystemInterfaceAdapter::GetReadWriteLockForCacheInvalidation() {
os::ReaderWriterLock &FileSystemInterfaceAdapter::GetReaderWriterLockForCacheInvalidation() {
return this->invalidation_lock;
}

4
libraries/libstratosphere/source/fssrv/fssrv_storage_interface_adapter.cpp
View File

@@ -34,8 +34,8 @@ namespace ams::fssrv::impl {
/* ... */
}
util::optional<std::shared_lock<os::ReadWriteLock>> StorageInterfaceAdapter::AcquireCacheInvalidationReadLock() {
util::optional<std::shared_lock<os::ReadWriteLock>> lock;
util::optional<std::shared_lock<os::ReaderWriterLock>> StorageInterfaceAdapter::AcquireCacheInvalidationReadLock() {
util::optional<std::shared_lock<os::ReaderWriterLock>> lock;
if (this->deep_retry_enabled) {
lock.emplace(this->invalidation_lock);
}

8
libraries/libstratosphere/source/os/impl/os_internal_rw_busy_mutex_impl.os.horizon.hpp
View File

@@ -101,7 +101,7 @@ namespace ams::os::impl {
}
void InternalReadWriteBusyMutexImpl::AcquireReadLock() {
void InternalReaderWriterBusyMutexImpl::AcquireReadLock() {
/* Get the thread local region. */
auto * const tlr = svc::GetThreadLocalRegion();
@@ -152,7 +152,7 @@ namespace ams::os::impl {
}
}
void InternalReadWriteBusyMutexImpl::ReleaseReadLock() {
void InternalReaderWriterBusyMutexImpl::ReleaseReadLock() {
/* Release the read lock. */
{
/* Get pointer to our value. */
@@ -183,7 +183,7 @@ namespace ams::os::impl {
}
}
void InternalReadWriteBusyMutexImpl::AcquireWriteLock() {
void InternalReaderWriterBusyMutexImpl::AcquireWriteLock() {
/* Get the thread local region. */
auto * const tlr = svc::GetThreadLocalRegion();
@@ -247,7 +247,7 @@ namespace ams::os::impl {
}
}
void InternalReadWriteBusyMutexImpl::ReleaseWriteLock() {
void InternalReaderWriterBusyMutexImpl::ReleaseWriteLock() {
/* Check pre-conditions. */
AMS_ABORT_UNLESS(IsWriteLocked(m_value));

116
libraries/libstratosphere/source/os/impl/os_rw_lock_impl.hpp
View File

@@ -19,40 +19,40 @@
#if defined(ATMOSPHERE_OS_HORIZON)
#include "os_rw_lock_target_impl.os.horizon.hpp"
#else
#error "Unknown OS for os::ReadWriteLockTargetImpl"
#error "Unknown OS for os::ReaderWriterLockTargetImpl"
#endif
namespace ams::os::impl {
static_assert(alignof(ReadWriteLockType) == sizeof(u64) || alignof(ReadWriteLockType) == sizeof(u32));
constexpr inline bool IsReadWriteLockGuaranteedAlignment = alignof(ReadWriteLockType) == sizeof(u64);
static_assert(alignof(ReaderWriterLockType) == sizeof(u64) || alignof(ReaderWriterLockType) == sizeof(u32));
constexpr inline bool IsReaderWriterLockGuaranteedAlignment = alignof(ReaderWriterLockType) == sizeof(u64);
struct ReadWriteLockCounter {
struct ReaderWriterLockCounter {
using ReadLockCount = util::BitPack32::Field< 0, BITSIZEOF(u16) - 1, u32>;
using WriteLocked = util::BitPack32::Field< ReadLockCount::Next, 1, u32>;
using ReadLockWaiterCount = util::BitPack32::Field< WriteLocked::Next, BITSIZEOF(u8), u32>;
using WriteLockWaiterCount = util::BitPack32::Field<ReadLockWaiterCount::Next, BITSIZEOF(u8), u32>;
};
static_assert(ReadWriteLockCounter::WriteLockWaiterCount::Next == BITSIZEOF(u32));
static_assert(ReaderWriterLockCounter::WriteLockWaiterCount::Next == BITSIZEOF(u32));
ALWAYS_INLINE void ClearReadLockCount(ReadWriteLockType::LockCount &lc) {
lc.counter.Set<ReadWriteLockCounter::ReadLockCount>(0);
ALWAYS_INLINE void ClearReadLockCount(ReaderWriterLockType::LockCount &lc) {
lc.counter.Set<ReaderWriterLockCounter::ReadLockCount>(0);
}
ALWAYS_INLINE void ClearWriteLocked(ReadWriteLockType::LockCount &lc) {
lc.counter.Set<ReadWriteLockCounter::WriteLocked>(0);
ALWAYS_INLINE void ClearWriteLocked(ReaderWriterLockType::LockCount &lc) {
lc.counter.Set<ReaderWriterLockCounter::WriteLocked>(0);
}
ALWAYS_INLINE void ClearReadLockWaiterCount(ReadWriteLockType::LockCount &lc) {
lc.counter.Set<ReadWriteLockCounter::ReadLockWaiterCount>(0);
ALWAYS_INLINE void ClearReadLockWaiterCount(ReaderWriterLockType::LockCount &lc) {
lc.counter.Set<ReaderWriterLockCounter::ReadLockWaiterCount>(0);
}
ALWAYS_INLINE void ClearWriteLockWaiterCount(ReadWriteLockType::LockCount &lc) {
lc.counter.Set<ReadWriteLockCounter::WriteLockWaiterCount>(0);
ALWAYS_INLINE void ClearWriteLockWaiterCount(ReaderWriterLockType::LockCount &lc) {
lc.counter.Set<ReaderWriterLockCounter::WriteLockWaiterCount>(0);
}
ALWAYS_INLINE void ClearWriteLockCount(ReadWriteLockType *rw_lock) {
if constexpr (IsReadWriteLockGuaranteedAlignment) {
ALWAYS_INLINE void ClearWriteLockCount(ReaderWriterLockType *rw_lock) {
if constexpr (IsReaderWriterLockGuaranteedAlignment) {
rw_lock->lock_count.aligned.write_lock_count = 0;
} else {
if (reinterpret_cast<uintptr_t>(std::addressof(rw_lock->lock_count)) & sizeof(u32)) {
@@ -63,8 +63,8 @@ namespace ams::os::impl {
}
}
ALWAYS_INLINE ReadWriteLockType::LockCount &GetLockCount(ReadWriteLockType *rw_lock) {
if constexpr (IsReadWriteLockGuaranteedAlignment) {
ALWAYS_INLINE ReaderWriterLockType::LockCount &GetLockCount(ReaderWriterLockType *rw_lock) {
if constexpr (IsReaderWriterLockGuaranteedAlignment) {
return rw_lock->lock_count.aligned.c;
} else {
if (reinterpret_cast<uintptr_t>(std::addressof(rw_lock->lock_count)) & sizeof(u32)) {
@@ -75,8 +75,8 @@ namespace ams::os::impl {
}
}
ALWAYS_INLINE const ReadWriteLockType::LockCount &GetLockCount(const ReadWriteLockType *rw_lock) {
if constexpr (IsReadWriteLockGuaranteedAlignment) {
ALWAYS_INLINE const ReaderWriterLockType::LockCount &GetLockCount(const ReaderWriterLockType *rw_lock) {
if constexpr (IsReaderWriterLockGuaranteedAlignment) {
return rw_lock->lock_count.aligned.c;
} else {
if (reinterpret_cast<uintptr_t>(std::addressof(rw_lock->lock_count)) & sizeof(u32)) {
@@ -87,24 +87,24 @@ namespace ams::os::impl {
}
}
ALWAYS_INLINE u32 GetReadLockCount(const ReadWriteLockType::LockCount &lc) {
return lc.counter.Get<ReadWriteLockCounter::ReadLockCount>();
ALWAYS_INLINE u32 GetReadLockCount(const ReaderWriterLockType::LockCount &lc) {
return lc.counter.Get<ReaderWriterLockCounter::ReadLockCount>();
}
ALWAYS_INLINE u32 GetWriteLocked(const ReadWriteLockType::LockCount &lc) {
return lc.counter.Get<ReadWriteLockCounter::WriteLocked>();
ALWAYS_INLINE u32 GetWriteLocked(const ReaderWriterLockType::LockCount &lc) {
return lc.counter.Get<ReaderWriterLockCounter::WriteLocked>();
}
ALWAYS_INLINE u32 GetReadLockWaiterCount(const ReadWriteLockType::LockCount &lc) {
return lc.counter.Get<ReadWriteLockCounter::ReadLockWaiterCount>();
ALWAYS_INLINE u32 GetReadLockWaiterCount(const ReaderWriterLockType::LockCount &lc) {
return lc.counter.Get<ReaderWriterLockCounter::ReadLockWaiterCount>();
}
ALWAYS_INLINE u32 GetWriteLockWaiterCount(const ReadWriteLockType::LockCount &lc) {
return lc.counter.Get<ReadWriteLockCounter::WriteLockWaiterCount>();
ALWAYS_INLINE u32 GetWriteLockWaiterCount(const ReaderWriterLockType::LockCount &lc) {
return lc.counter.Get<ReaderWriterLockCounter::WriteLockWaiterCount>();
}
ALWAYS_INLINE u32 &GetWriteLockCount(ReadWriteLockType &rw_lock) {
if constexpr (IsReadWriteLockGuaranteedAlignment) {
ALWAYS_INLINE u32 &GetWriteLockCount(ReaderWriterLockType &rw_lock) {
if constexpr (IsReaderWriterLockGuaranteedAlignment) {
return rw_lock.lock_count.aligned.write_lock_count;
} else {
if (reinterpret_cast<uintptr_t>(std::addressof(rw_lock.lock_count)) & sizeof(u32)) {
@@ -115,8 +115,8 @@ namespace ams::os::impl {
}
}
ALWAYS_INLINE const u32 &GetWriteLockCount(const ReadWriteLockType &rw_lock) {
if constexpr (IsReadWriteLockGuaranteedAlignment) {
ALWAYS_INLINE const u32 &GetWriteLockCount(const ReaderWriterLockType &rw_lock) {
if constexpr (IsReaderWriterLockGuaranteedAlignment) {
return rw_lock.lock_count.aligned.write_lock_count;
} else {
if (reinterpret_cast<uintptr_t>(std::addressof(rw_lock.lock_count)) & sizeof(u32)) {
@@ -127,59 +127,59 @@ namespace ams::os::impl {
}
}
ALWAYS_INLINE void IncReadLockCount(ReadWriteLockType::LockCount &lc) {
const u32 read_lock_count = lc.counter.Get<ReadWriteLockCounter::ReadLockCount>();
AMS_ASSERT(read_lock_count < ReadWriteLockCountMax);
lc.counter.Set<ReadWriteLockCounter::ReadLockCount>(read_lock_count + 1);
ALWAYS_INLINE void IncReadLockCount(ReaderWriterLockType::LockCount &lc) {
const u32 read_lock_count = lc.counter.Get<ReaderWriterLockCounter::ReadLockCount>();
AMS_ASSERT(read_lock_count < ReaderWriterLockCountMax);
lc.counter.Set<ReaderWriterLockCounter::ReadLockCount>(read_lock_count + 1);
}
ALWAYS_INLINE void DecReadLockCount(ReadWriteLockType::LockCount &lc) {
const u32 read_lock_count = lc.counter.Get<ReadWriteLockCounter::ReadLockCount>();
ALWAYS_INLINE void DecReadLockCount(ReaderWriterLockType::LockCount &lc) {
const u32 read_lock_count = lc.counter.Get<ReaderWriterLockCounter::ReadLockCount>();
AMS_ASSERT(read_lock_count > 0);
lc.counter.Set<ReadWriteLockCounter::ReadLockCount>(read_lock_count - 1);
lc.counter.Set<ReaderWriterLockCounter::ReadLockCount>(read_lock_count - 1);
}
ALWAYS_INLINE void IncReadLockWaiterCount(ReadWriteLockType::LockCount &lc) {
const u32 read_lock_waiter_count = lc.counter.Get<ReadWriteLockCounter::ReadLockWaiterCount>();
AMS_ASSERT(read_lock_waiter_count < ReadWriteLockWaiterCountMax);
lc.counter.Set<ReadWriteLockCounter::ReadLockWaiterCount>(read_lock_waiter_count + 1);
ALWAYS_INLINE void IncReadLockWaiterCount(ReaderWriterLockType::LockCount &lc) {
const u32 read_lock_waiter_count = lc.counter.Get<ReaderWriterLockCounter::ReadLockWaiterCount>();
AMS_ASSERT(read_lock_waiter_count < ReaderWriterLockWaiterCountMax);
lc.counter.Set<ReaderWriterLockCounter::ReadLockWaiterCount>(read_lock_waiter_count + 1);
}
ALWAYS_INLINE void DecReadLockWaiterCount(ReadWriteLockType::LockCount &lc) {
const u32 read_lock_waiter_count = lc.counter.Get<ReadWriteLockCounter::ReadLockWaiterCount>();
ALWAYS_INLINE void DecReadLockWaiterCount(ReaderWriterLockType::LockCount &lc) {
const u32 read_lock_waiter_count = lc.counter.Get<ReaderWriterLockCounter::ReadLockWaiterCount>();
AMS_ASSERT(read_lock_waiter_count > 0);
lc.counter.Set<ReadWriteLockCounter::ReadLockWaiterCount>(read_lock_waiter_count - 1);
lc.counter.Set<ReaderWriterLockCounter::ReadLockWaiterCount>(read_lock_waiter_count - 1);
}
ALWAYS_INLINE void IncWriteLockWaiterCount(ReadWriteLockType::LockCount &lc) {
const u32 write_lock_waiter_count = lc.counter.Get<ReadWriteLockCounter::WriteLockWaiterCount>();
AMS_ASSERT(write_lock_waiter_count < ReadWriteLockWaiterCountMax);
lc.counter.Set<ReadWriteLockCounter::WriteLockWaiterCount>(write_lock_waiter_count + 1);
ALWAYS_INLINE void IncWriteLockWaiterCount(ReaderWriterLockType::LockCount &lc) {
const u32 write_lock_waiter_count = lc.counter.Get<ReaderWriterLockCounter::WriteLockWaiterCount>();
AMS_ASSERT(write_lock_waiter_count < ReaderWriterLockWaiterCountMax);
lc.counter.Set<ReaderWriterLockCounter::WriteLockWaiterCount>(write_lock_waiter_count + 1);
}
ALWAYS_INLINE void DecWriteLockWaiterCount(ReadWriteLockType::LockCount &lc) {
const u32 write_lock_waiter_count = lc.counter.Get<ReadWriteLockCounter::WriteLockWaiterCount>();
ALWAYS_INLINE void DecWriteLockWaiterCount(ReaderWriterLockType::LockCount &lc) {
const u32 write_lock_waiter_count = lc.counter.Get<ReaderWriterLockCounter::WriteLockWaiterCount>();
AMS_ASSERT(write_lock_waiter_count > 0);
lc.counter.Set<ReadWriteLockCounter::WriteLockWaiterCount>(write_lock_waiter_count - 1);
lc.counter.Set<ReaderWriterLockCounter::WriteLockWaiterCount>(write_lock_waiter_count - 1);
}
ALWAYS_INLINE void IncWriteLockCount(ReadWriteLockType &rw_lock) {
ALWAYS_INLINE void IncWriteLockCount(ReaderWriterLockType &rw_lock) {
u32 &write_lock_count = GetWriteLockCount(rw_lock);
AMS_ASSERT(write_lock_count < ReadWriteLockCountMax);
AMS_ASSERT(write_lock_count < ReaderWriterLockCountMax);
++write_lock_count;
}
ALWAYS_INLINE void DecWriteLockCount(ReadWriteLockType &rw_lock) {
ALWAYS_INLINE void DecWriteLockCount(ReaderWriterLockType &rw_lock) {
u32 &write_lock_count = GetWriteLockCount(rw_lock);
AMS_ASSERT(write_lock_count > 0);
--write_lock_count;
}
ALWAYS_INLINE void SetWriteLocked(ReadWriteLockType::LockCount &lc) {
lc.counter.Set<ReadWriteLockCounter::WriteLocked>(1);
ALWAYS_INLINE void SetWriteLocked(ReaderWriterLockType::LockCount &lc) {
lc.counter.Set<ReaderWriterLockCounter::WriteLocked>(1);
}
using ReadWriteLockImpl = ReadWriteLockTargetImpl;
using ReaderWriterLockImpl = ReaderWriterLockTargetImpl;
}

18
libraries/libstratosphere/source/os/impl/os_rw_lock_target_impl.os.horizon.cpp
View File

@@ -23,7 +23,7 @@ namespace ams::os::impl {
(__atomic_compare_exchange(reinterpret_cast<u64 *>(&dst_ref), reinterpret_cast<u64 *>(&expected_ref), reinterpret_cast<u64 *>(&desired_ref), true, success, fail))
void ReadWriteLockHorizonImpl::AcquireReadLockWriteLocked(os::ReadWriteLockType *rw_lock) {
void ReaderWriterLockHorizonImpl::AcquireReadLockWriteLocked(os::ReaderWriterLockType *rw_lock) {
AMS_ASSERT(GetWriteLocked(GetLockCount(rw_lock)) == 1);
AMS_ASSERT((GetThreadHandle(GetLockCount(rw_lock)) | svc::HandleWaitMask) == (impl::GetCurrentThreadHandle() | svc::HandleWaitMask));
alignas(alignof(u64)) LockCount expected = GetLockCount(rw_lock);
@@ -34,7 +34,7 @@ namespace ams::os::impl {
} while (!ATOMIC_COMPARE_EXCHANGE_LOCK_COUNT(GetLockCount(rw_lock), expected, lock_count, __ATOMIC_RELAXED, __ATOMIC_RELAXED));
}
void ReadWriteLockHorizonImpl::ReleaseReadLockWriteLocked(os::ReadWriteLockType *rw_lock) {
void ReaderWriterLockHorizonImpl::ReleaseReadLockWriteLocked(os::ReaderWriterLockType *rw_lock) {
AMS_ASSERT(GetWriteLocked(GetLockCount(rw_lock)) == 1);
AMS_ASSERT((GetThreadHandle(GetLockCount(rw_lock)) | svc::HandleWaitMask) == (impl::GetCurrentThreadHandle() | svc::HandleWaitMask));
alignas(alignof(u64)) LockCount expected = GetLockCount(rw_lock);
@@ -46,7 +46,7 @@ namespace ams::os::impl {
return ReleaseWriteLockImpl(rw_lock);
}
void ReadWriteLockHorizonImpl::ReleaseWriteLockImpl(os::ReadWriteLockType *rw_lock) {
void ReaderWriterLockHorizonImpl::ReleaseWriteLockImpl(os::ReaderWriterLockType *rw_lock) {
alignas(alignof(u64)) LockCount expected = GetLockCount(rw_lock);
alignas(alignof(u64)) LockCount lock_count = expected;
AMS_ASSERT(GetWriteLocked(lock_count) == 1);
@@ -70,7 +70,7 @@ namespace ams::os::impl {
}
}
void ReadWriteLockHorizonImpl::AcquireReadLock(os::ReadWriteLockType *rw_lock) {
void ReaderWriterLockHorizonImpl::AcquireReadLock(os::ReaderWriterLockType *rw_lock) {
AMS_ASSERT(::ams::svc::GetThreadLocalRegion()->disable_count == 0);
auto *cur_thread = impl::GetCurrentThread();
@@ -143,7 +143,7 @@ namespace ams::os::impl {
}
}
bool ReadWriteLockHorizonImpl::TryAcquireReadLock(os::ReadWriteLockType *rw_lock) {
bool ReaderWriterLockHorizonImpl::TryAcquireReadLock(os::ReaderWriterLockType *rw_lock) {
AMS_ASSERT(::ams::svc::GetThreadLocalRegion()->disable_count == 0);
auto *cur_thread = impl::GetCurrentThread();
@@ -168,7 +168,7 @@ namespace ams::os::impl {
}
}
void ReadWriteLockHorizonImpl::ReleaseReadLock(os::ReadWriteLockType *rw_lock) {
void ReaderWriterLockHorizonImpl::ReleaseReadLock(os::ReaderWriterLockType *rw_lock) {
AMS_ASSERT(::ams::svc::GetThreadLocalRegion()->disable_count == 0);
AMS_ASSERT(GetReadLockCount(GetLockCount(rw_lock)) > 0);
@@ -226,7 +226,7 @@ namespace ams::os::impl {
}
}
void ReadWriteLockHorizonImpl::AcquireWriteLock(os::ReadWriteLockType *rw_lock) {
void ReaderWriterLockHorizonImpl::AcquireWriteLock(os::ReaderWriterLockType *rw_lock) {
AMS_ASSERT(::ams::svc::GetThreadLocalRegion()->disable_count == 0);
auto *cur_thread = impl::GetCurrentThread();
@@ -301,7 +301,7 @@ namespace ams::os::impl {
}
}
bool ReadWriteLockHorizonImpl::TryAcquireWriteLock(os::ReadWriteLockType *rw_lock) {
bool ReaderWriterLockHorizonImpl::TryAcquireWriteLock(os::ReaderWriterLockType *rw_lock) {
AMS_ASSERT(::ams::svc::GetThreadLocalRegion()->disable_count == 0);
auto *cur_thread = impl::GetCurrentThread();
@@ -334,7 +334,7 @@ namespace ams::os::impl {
}
}
void ReadWriteLockHorizonImpl::ReleaseWriteLock(os::ReadWriteLockType *rw_lock) {
void ReaderWriterLockHorizonImpl::ReleaseWriteLock(os::ReaderWriterLockType *rw_lock) {
AMS_ASSERT(::ams::svc::GetThreadLocalRegion()->disable_count == 0);
AMS_ASSERT(GetWriteLockCount(*rw_lock) > 0);

24
libraries/libstratosphere/source/os/impl/os_rw_lock_target_impl.os.horizon.hpp
View File

@@ -18,9 +18,9 @@
namespace ams::os::impl {
class ReadWriteLockHorizonImpl {
class ReaderWriterLockHorizonImpl {
private:
using LockCount = os::ReadWriteLockType::LockCount;
using LockCount = os::ReaderWriterLockType::LockCount;
private:
static ALWAYS_INLINE u32 GetThreadHandle(const LockCount &lc) {
return GetReference(lc.cs_storage).Get()->thread_handle;
@@ -34,19 +34,19 @@ namespace ams::os::impl {
GetReference(lc.cs_storage).Get()->thread_handle = handle;
}
static void AcquireReadLockWriteLocked(os::ReadWriteLockType *rw_lock);
static void ReleaseReadLockWriteLocked(os::ReadWriteLockType *rw_lock);
static void ReleaseWriteLockImpl(os::ReadWriteLockType *rw_lock);
static void AcquireReadLockWriteLocked(os::ReaderWriterLockType *rw_lock);
static void ReleaseReadLockWriteLocked(os::ReaderWriterLockType *rw_lock);
static void ReleaseWriteLockImpl(os::ReaderWriterLockType *rw_lock);
public:
static void AcquireReadLock(os::ReadWriteLockType *rw_lock);
static bool TryAcquireReadLock(os::ReadWriteLockType *rw_lock);
static void ReleaseReadLock(os::ReadWriteLockType *rw_lock);
static void AcquireReadLock(os::ReaderWriterLockType *rw_lock);
static bool TryAcquireReadLock(os::ReaderWriterLockType *rw_lock);
static void ReleaseReadLock(os::ReaderWriterLockType *rw_lock);
static void AcquireWriteLock(os::ReadWriteLockType *rw_lock);
static bool TryAcquireWriteLock(os::ReadWriteLockType *rw_lock);
static void ReleaseWriteLock(os::ReadWriteLockType *rw_lock);
static void AcquireWriteLock(os::ReaderWriterLockType *rw_lock);
static bool TryAcquireWriteLock(os::ReaderWriterLockType *rw_lock);
static void ReleaseWriteLock(os::ReaderWriterLockType *rw_lock);
};
using ReadWriteLockTargetImpl = ReadWriteLockHorizonImpl;
using ReaderWriterLockTargetImpl = ReaderWriterLockHorizonImpl;
}

12
libraries/libstratosphere/source/os/os_rw_busy_mutex.cpp
View File

@@ -19,32 +19,32 @@
#if defined(ATMOSPHERE_OS_HORIZON)
#include "impl/os_internal_rw_busy_mutex_impl.os.horizon.hpp"
#else
#error "Unknown OS for ams::os::impl::InternalReadWriteBusyMutexImpl"
#error "Unknown OS for ams::os::impl::InternalReaderWriterBusyMutexImpl"
#endif
namespace ams::os {
void InitalizeReadWriteLockBusyMutex(ReadWriteBusyMutexType *rw_mutex) {
void InitalizeReaderWriterLockBusyMutex(ReaderWriterBusyMutexType *rw_mutex) {
/* Create object. */
util::ConstructAt(rw_mutex->_storage);
}
void AcquireReadLockBusyMutex(ReadWriteBusyMutexType *rw_mutex) {
void AcquireReadLockBusyMutex(ReaderWriterBusyMutexType *rw_mutex) {
/* Acquire read lock. */
util::GetReference(rw_mutex->_storage).AcquireReadLock();
}
void ReleaseReadLockBusyMutex(ReadWriteBusyMutexType *rw_mutex) {
void ReleaseReadLockBusyMutex(ReaderWriterBusyMutexType *rw_mutex) {
/* Release read lock. */
util::GetReference(rw_mutex->_storage).ReleaseReadLock();
}
void AcquireWriteLockBusyMutex(ReadWriteBusyMutexType *rw_mutex) {
void AcquireWriteLockBusyMutex(ReaderWriterBusyMutexType *rw_mutex) {
/* Acquire write lock. */
util::GetReference(rw_mutex->_storage).AcquireWriteLock();
}
void ReleaseWriteLockBusyMutex(ReadWriteBusyMutexType *rw_mutex) {
void ReleaseWriteLockBusyMutex(ReaderWriterBusyMutexType *rw_mutex) {
/* Release write lock. */
util::GetReference(rw_mutex->_storage).ReleaseWriteLock();
}

58
libraries/libstratosphere/source/os/os_rw_lock.cpp
View File

@@ -19,7 +19,7 @@
namespace ams::os {
void InitalizeReadWriteLock(ReadWriteLockType *rw_lock) {
void InitalizeReaderWriterLock(ReaderWriterLockType *rw_lock) {
/* Create objects. */
util::ConstructAt(impl::GetLockCount(rw_lock).cs_storage);
util::ConstructAt(rw_lock->cv_read_lock._storage);
@@ -34,18 +34,18 @@ namespace ams::os {
rw_lock->owner_thread = nullptr;
/* Mark initialized. */
rw_lock->state = ReadWriteLockType::State_Initialized;
rw_lock->state = ReaderWriterLockType::State_Initialized;
}
void FinalizeReadWriteLock(ReadWriteLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReadWriteLockType::State_Initialized);
void FinalizeReaderWriterLock(ReaderWriterLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReaderWriterLockType::State_Initialized);
/* Don't allow finalizing a locked lock. */
AMS_ASSERT(impl::GetReadLockCount(impl::GetLockCount(rw_lock)) == 0);
AMS_ASSERT(impl::GetWriteLocked(impl::GetLockCount(rw_lock)) == 0);
/* Mark not initialized. */
rw_lock->state = ReadWriteLockType::State_NotInitialized;
rw_lock->state = ReaderWriterLockType::State_NotInitialized;
/* Destroy objects. */
util::DestroyAt(rw_lock->cv_write_lock._storage);
@@ -53,49 +53,49 @@ namespace ams::os {
util::DestroyAt(impl::GetLockCount(rw_lock).cs_storage);
}
void AcquireReadLock(ReadWriteLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReadWriteLockType::State_Initialized);
return impl::ReadWriteLockImpl::AcquireReadLock(rw_lock);
void AcquireReadLock(ReaderWriterLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReaderWriterLockType::State_Initialized);
return impl::ReaderWriterLockImpl::AcquireReadLock(rw_lock);
}
bool TryAcquireReadLock(ReadWriteLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReadWriteLockType::State_Initialized);
return impl::ReadWriteLockImpl::TryAcquireReadLock(rw_lock);
bool TryAcquireReadLock(ReaderWriterLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReaderWriterLockType::State_Initialized);
return impl::ReaderWriterLockImpl::TryAcquireReadLock(rw_lock);
}
void ReleaseReadLock(ReadWriteLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReadWriteLockType::State_Initialized);
return impl::ReadWriteLockImpl::ReleaseReadLock(rw_lock);
void ReleaseReadLock(ReaderWriterLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReaderWriterLockType::State_Initialized);
return impl::ReaderWriterLockImpl::ReleaseReadLock(rw_lock);
}
void AcquireWriteLock(ReadWriteLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReadWriteLockType::State_Initialized);
return impl::ReadWriteLockImpl::AcquireWriteLock(rw_lock);
void AcquireWriteLock(ReaderWriterLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReaderWriterLockType::State_Initialized);
return impl::ReaderWriterLockImpl::AcquireWriteLock(rw_lock);
}
bool TryAcquireWriteLock(ReadWriteLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReadWriteLockType::State_Initialized);
return impl::ReadWriteLockImpl::TryAcquireWriteLock(rw_lock);
bool TryAcquireWriteLock(ReaderWriterLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReaderWriterLockType::State_Initialized);
return impl::ReaderWriterLockImpl::TryAcquireWriteLock(rw_lock);
}
void ReleaseWriteLock(ReadWriteLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReadWriteLockType::State_Initialized);
void ReleaseWriteLock(ReaderWriterLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReaderWriterLockType::State_Initialized);
AMS_ABORT_UNLESS(rw_lock->owner_thread == impl::GetCurrentThread());
return impl::ReadWriteLockImpl::ReleaseWriteLock(rw_lock);
return impl::ReaderWriterLockImpl::ReleaseWriteLock(rw_lock);
}
bool IsReadLockHeld(const ReadWriteLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReadWriteLockType::State_Initialized);
bool IsReadLockHeld(const ReaderWriterLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReaderWriterLockType::State_Initialized);
return impl::GetReadLockCount(impl::GetLockCount(rw_lock)) != 0;
}
bool IsWriteLockHeldByCurrentThread(const ReadWriteLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReadWriteLockType::State_Initialized);
bool IsWriteLockHeldByCurrentThread(const ReaderWriterLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReaderWriterLockType::State_Initialized);
return rw_lock->owner_thread == impl::GetCurrentThread() && impl::GetWriteLockCount(*rw_lock) != 0;
}
bool IsReadWriteLockOwnerThread(const ReadWriteLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReadWriteLockType::State_Initialized);
bool IsReaderWriterLockOwnerThread(const ReaderWriterLockType *rw_lock) {
AMS_ASSERT(rw_lock->state == ReaderWriterLockType::State_Initialized);
return rw_lock->owner_thread == impl::GetCurrentThread();
}