nold/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere synced 2024-09-19 22:59:00 +00:00
Code Issues 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
Show stats Download patch file Download diff file Expand all files Collapse all files

6
libraries/libstratosphere/include/stratosphere/fssrv/interface_adapters/fssrv_filesystem_interface_adapter.hpp
View file

@ -81,7 +81,7 @@ namespace ams::fssrv::impl {
private: private:
std::shared_ptr<fs::fsa::IFileSystem> base_fs; std::shared_ptr<fs::fsa::IFileSystem> base_fs;
util::unique_lock<fssystem::SemaphoreAdapter> mount_count_semaphore; util::unique_lock<fssystem::SemaphoreAdapter> mount_count_semaphore;
os::ReadWriteLock invalidation_lock; os::ReaderWriterLock invalidation_lock;
bool open_count_limited; bool open_count_limited;
bool deep_retry_enabled = false; bool deep_retry_enabled = false;
public: public:
@ -92,8 +92,8 @@ namespace ams::fssrv::impl {
public: public:
bool IsDeepRetryEnabled() const; bool IsDeepRetryEnabled() const;
bool IsAccessFailureDetectionObserved() const; bool IsAccessFailureDetectionObserved() const;
util::optional<std::shared_lock<os::ReadWriteLock>> AcquireCacheInvalidationReadLock(); util::optional<std::shared_lock<os::ReaderWriterLock>> AcquireCacheInvalidationReadLock();
os::ReadWriteLock &GetReadWriteLockForCacheInvalidation(); os::ReaderWriterLock &GetReaderWriterLockForCacheInvalidation();
public: public:
/* Command API. */ /* Command API. */
Result CreateFile(const fssrv::sf::Path &path, s64 size, s32 option); Result CreateFile(const fssrv::sf::Path &path, s64 size, s32 option);

4
libraries/libstratosphere/include/stratosphere/fssrv/interface_adapters/fssrv_storage_interface_adapter.hpp
View file

@ -33,7 +33,7 @@ namespace ams::fssrv::impl {
/* TODO: Nintendo uses fssystem::AsynchronousAccessStorage here. */ /* TODO: Nintendo uses fssystem::AsynchronousAccessStorage here. */
std::shared_ptr<fs::IStorage> base_storage; std::shared_ptr<fs::IStorage> base_storage;
util::unique_lock<fssystem::SemaphoreAdapter> open_count_semaphore; util::unique_lock<fssystem::SemaphoreAdapter> open_count_semaphore;
os::ReadWriteLock invalidation_lock; os::ReaderWriterLock invalidation_lock;
/* TODO: DataStorageContext. */ /* TODO: DataStorageContext. */
bool deep_retry_enabled = false; bool deep_retry_enabled = false;
public: public:
@ -44,7 +44,7 @@ namespace ams::fssrv::impl {
~StorageInterfaceAdapter(); ~StorageInterfaceAdapter();
private: private:
util::optional<std::shared_lock<os::ReadWriteLock>> AcquireCacheInvalidationReadLock(); util::optional<std::shared_lock<os::ReaderWriterLock>> AcquireCacheInvalidationReadLock();
public: public:
/* Command API. */ /* Command API. */
Result Read(s64 offset, const ams::sf::OutNonSecureBuffer &buffer, s64 size); Result Read(s64 offset, const ams::sf::OutNonSecureBuffer &buffer, s64 size);

4
libraries/libstratosphere/include/stratosphere/os/impl/os_internal_critical_section_impl.os.horizon.hpp
View file

@ -20,7 +20,7 @@
namespace ams::os::impl { namespace ams::os::impl {
#if defined(ATMOSPHERE_OS_HORIZON) #if defined(ATMOSPHERE_OS_HORIZON)
class ReadWriteLockHorizonImpl; class ReaderWriterLockHorizonImpl;
#endif #endif
class InternalConditionVariableImpl; class InternalConditionVariableImpl;
@ -28,7 +28,7 @@ namespace ams::os::impl {
class InternalCriticalSectionImpl { class InternalCriticalSectionImpl {
private: private:
#if defined(ATMOSPHERE_OS_HORIZON) #if defined(ATMOSPHERE_OS_HORIZON)
friend class ReadWriteLockHorizonImpl; friend class ReaderWriterLockHorizonImpl;
#endif #endif
friend class InternalConditionVariableImpl; friend class InternalConditionVariableImpl;

10
libraries/libstratosphere/include/stratosphere/os/impl/os_internal_rw_busy_mutex.hpp
View file

@ -20,16 +20,16 @@
#if defined(ATMOSPHERE_OS_HORIZON) #if defined(ATMOSPHERE_OS_HORIZON)
#include <stratosphere/os/impl/os_internal_rw_busy_mutex_impl.os.horizon.hpp> #include <stratosphere/os/impl/os_internal_rw_busy_mutex_impl.os.horizon.hpp>
#else #else
#error "Unknown OS for ams::os::impl::InternalReadWriteBusyMutexImpl" #error "Unknown OS for ams::os::impl::InternalReaderWriterBusyMutexImpl"
#endif #endif
namespace ams::os::impl { namespace ams::os::impl {
class InternalReadWriteBusyMutex { class InternalReaderWriterBusyMutex {
private: private:
InternalReadWriteBusyMutexImpl m_impl; InternalReaderWriterBusyMutexImpl m_impl;
public: public:
constexpr InternalReadWriteBusyMutex() : m_impl() { /* ... */ } constexpr InternalReaderWriterBusyMutex() : m_impl() { /* ... */ }
ALWAYS_INLINE void AcquireReadLock() { return m_impl.AcquireReadLock(); } ALWAYS_INLINE void AcquireReadLock() { return m_impl.AcquireReadLock(); }
ALWAYS_INLINE void ReleaseReadLock() { return m_impl.ReleaseReadLock(); } ALWAYS_INLINE void ReleaseReadLock() { return m_impl.ReleaseReadLock(); }
@ -38,6 +38,6 @@ namespace ams::os::impl {
ALWAYS_INLINE void ReleaseWriteLock() { return m_impl.ReleaseWriteLock(); } ALWAYS_INLINE void ReleaseWriteLock() { return m_impl.ReleaseWriteLock(); }
}; };
using InternalReadWriteBusyMutexStorage = util::TypedStorage<InternalReadWriteBusyMutex>; using InternalReaderWriterBusyMutexStorage = util::TypedStorage<InternalReaderWriterBusyMutex>;
} }

4
libraries/libstratosphere/include/stratosphere/os/impl/os_internal_rw_busy_mutex_impl.os.horizon.hpp
View file

@ -19,11 +19,11 @@
namespace ams::os::impl { namespace ams::os::impl {
class InternalReadWriteBusyMutexImpl { class InternalReaderWriterBusyMutexImpl {
private: private:
u32 m_value; u32 m_value;
public: public:
constexpr InternalReadWriteBusyMutexImpl() : m_value(0) { /* ... */ } constexpr InternalReaderWriterBusyMutexImpl() : m_value(0) { /* ... */ }
constexpr void Initialize() { m_value = 0; } constexpr void Initialize() { m_value = 0; }

16
libraries/libstratosphere/include/stratosphere/os/os_rw_busy_mutex.hpp
View file

@ -20,13 +20,13 @@
namespace ams::os { namespace ams::os {
class ReadWriteBusyMutex { class ReaderWriterBusyMutex {
NON_COPYABLE(ReadWriteBusyMutex); NON_COPYABLE(ReaderWriterBusyMutex);
NON_MOVEABLE(ReadWriteBusyMutex); NON_MOVEABLE(ReaderWriterBusyMutex);
private: private:
ReadWriteBusyMutexType m_rw_mutex; ReaderWriterBusyMutexType m_rw_mutex;
public: public:
constexpr explicit ReadWriteBusyMutex() : m_rw_mutex{{0}} { /* ... */ } constexpr explicit ReaderWriterBusyMutex() : m_rw_mutex{{0}} { /* ... */ }
void AcquireReadLock() { void AcquireReadLock() {
return os::AcquireReadLockBusyMutex(std::addressof(m_rw_mutex)); return os::AcquireReadLockBusyMutex(std::addressof(m_rw_mutex));
@ -60,15 +60,15 @@ namespace ams::os {
return this->ReleaseWriteLock(); return this->ReleaseWriteLock();
} }
operator ReadWriteBusyMutexType &() { operator ReaderWriterBusyMutexType &() {
return m_rw_mutex; return m_rw_mutex;
} }
operator const ReadWriteBusyMutexType &() const { operator const ReaderWriterBusyMutexType &() const {
return m_rw_mutex; return m_rw_mutex;
} }
ReadWriteBusyMutexType *GetBase() { ReaderWriterBusyMutexType *GetBase() {
return std::addressof(m_rw_mutex); return std::addressof(m_rw_mutex);
} }
}; };

12
libraries/libstratosphere/include/stratosphere/os/os_rw_busy_mutex_api.hpp
View file

@ -19,14 +19,14 @@
namespace ams::os { namespace ams::os {
struct ReadWriteBusyMutexType; struct ReaderWriterBusyMutexType;
void InitalizeReadWriteLockBusyMutex(ReadWriteBusyMutexType *rw_mutex); void InitalizeReaderWriterLockBusyMutex(ReaderWriterBusyMutexType *rw_mutex);
void AcquireReadLockBusyMutex(ReadWriteBusyMutexType *rw_mutex); void AcquireReadLockBusyMutex(ReaderWriterBusyMutexType *rw_mutex);
void ReleaseReadLockBusyMutex(ReadWriteBusyMutexType *rw_mutex); void ReleaseReadLockBusyMutex(ReaderWriterBusyMutexType *rw_mutex);
void AcquireWriteLockBusyMutex(ReadWriteBusyMutexType *rw_mutex); void AcquireWriteLockBusyMutex(ReaderWriterBusyMutexType *rw_mutex);
void ReleaseWriteLockBusyMutex(ReadWriteBusyMutexType *rw_mutex); void ReleaseWriteLockBusyMutex(ReaderWriterBusyMutexType *rw_mutex);
} }

8
libraries/libstratosphere/include/stratosphere/os/os_rw_busy_mutex_types.hpp
View file

@ -20,12 +20,12 @@
namespace ams::os { namespace ams::os {
struct ReadWriteBusyMutexType { struct ReaderWriterBusyMutexType {
union { union {
s32 _arr[sizeof(impl::InternalReadWriteBusyMutexStorage) / sizeof(s32)]; s32 _arr[sizeof(impl::InternalReaderWriterBusyMutexStorage) / sizeof(s32)];
impl::InternalReadWriteBusyMutexStorage _storage; impl::InternalReaderWriterBusyMutexStorage _storage;
}; };
}; };
static_assert(std::is_trivial<ReadWriteBusyMutexType>::value); static_assert(std::is_trivial<ReaderWriterBusyMutexType>::value);
} }

20
libraries/libstratosphere/include/stratosphere/os/os_rw_lock.hpp
View file

@ -21,15 +21,15 @@
namespace ams::os { namespace ams::os {
class ReadWriteLock { class ReaderWriterLock {
NON_COPYABLE(ReadWriteLock); NON_COPYABLE(ReaderWriterLock);
NON_MOVEABLE(ReadWriteLock); NON_MOVEABLE(ReaderWriterLock);
private: private:
ReadWriteLockType rw_lock; ReaderWriterLockType rw_lock;
public: public:
constexpr explicit ReadWriteLock() : rw_lock{{}, 0, ::ams::os::ReadWriteLockType::State_Initialized, nullptr, 0, {}, {}} { /* ... */ } constexpr explicit ReaderWriterLock() : rw_lock{{}, 0, ::ams::os::ReaderWriterLockType::State_Initialized, nullptr, 0, {}, {}} { /* ... */ }
~ReadWriteLock() { os::FinalizeReadWriteLock(std::addressof(this->rw_lock)); } ~ReaderWriterLock() { os::FinalizeReaderWriterLock(std::addressof(this->rw_lock)); }
void AcquireReadLock() { void AcquireReadLock() {
return os::AcquireReadLock(std::addressof(this->rw_lock)); return os::AcquireReadLock(std::addressof(this->rw_lock));
@ -64,7 +64,7 @@ namespace ams::os {
} }
bool IsLockOwner() const { bool IsLockOwner() const {
return os::IsReadWriteLockOwnerThread(std::addressof(this->rw_lock)); return os::IsReaderWriterLockOwnerThread(std::addressof(this->rw_lock));
} }
void lock_shared() { void lock_shared() {
@ -91,15 +91,15 @@ namespace ams::os {
return this->ReleaseWriteLock(); return this->ReleaseWriteLock();
} }
operator ReadWriteLockType &() { operator ReaderWriterLockType &() {
return this->rw_lock; return this->rw_lock;
} }
operator const ReadWriteLockType &() const { operator const ReaderWriterLockType &() const {
return this->rw_lock; return this->rw_lock;
} }
ReadWriteLockType *GetBase() { ReaderWriterLockType *GetBase() {
return std::addressof(this->rw_lock); return std::addressof(this->rw_lock);
} }
}; };

24
libraries/libstratosphere/include/stratosphere/os/os_rw_lock_api.hpp
View file

@ -20,21 +20,21 @@
namespace ams::os { namespace ams::os {
struct ReadWriteLockType; struct ReaderWriterLockType;
void InitalizeReadWriteLock(ReadWriteLockType *rw_lock); void InitalizeReaderWriterLock(ReaderWriterLockType *rw_lock);
void FinalizeReadWriteLock(ReadWriteLockType *rw_lock); void FinalizeReaderWriterLock(ReaderWriterLockType *rw_lock);
void AcquireReadLock(ReadWriteLockType *rw_lock); void AcquireReadLock(ReaderWriterLockType *rw_lock);
bool TryAcquireReadLock(ReadWriteLockType *rw_lock); bool TryAcquireReadLock(ReaderWriterLockType *rw_lock);
void ReleaseReadLock(ReadWriteLockType *rw_lock); void ReleaseReadLock(ReaderWriterLockType *rw_lock);
void AcquireWriteLock(ReadWriteLockType *rw_lock); void AcquireWriteLock(ReaderWriterLockType *rw_lock);
bool TryAcquireWriteLock(ReadWriteLockType *rw_lock); bool TryAcquireWriteLock(ReaderWriterLockType *rw_lock);
void ReleaseWriteLock(ReadWriteLockType *rw_lock); void ReleaseWriteLock(ReaderWriterLockType *rw_lock);
bool IsReadLockHeld(const ReadWriteLockType *rw_lock); bool IsReadLockHeld(const ReaderWriterLockType *rw_lock);
bool IsWriteLockHeldByCurrentThread(const ReadWriteLockType *rw_lock); bool IsWriteLockHeldByCurrentThread(const ReaderWriterLockType *rw_lock);
bool IsReadWriteLockOwnerThread(const ReadWriteLockType *rw_lock); bool IsReaderWriterLockOwnerThread(const ReaderWriterLockType *rw_lock);
} }

4
libraries/libstratosphere/include/stratosphere/os/os_rw_lock_common.hpp
View file

@ -18,7 +18,7 @@
namespace ams::os { namespace ams::os {
constexpr inline s32 ReadWriteLockCountMax = (1 << (BITSIZEOF(u16) - 1)) - 1; constexpr inline s32 ReaderWriterLockCountMax = (1 << (BITSIZEOF(u16) - 1)) - 1;
constexpr inline s32 ReadWriteLockWaiterCountMax = (1 << BITSIZEOF(u8)) - 1; constexpr inline s32 ReaderWriterLockWaiterCountMax = (1 << BITSIZEOF(u8)) - 1;
} }

4
libraries/libstratosphere/include/stratosphere/os/os_rw_lock_types.hpp
View file

@ -23,7 +23,7 @@ namespace ams::os {
struct ThreadType; struct ThreadType;
struct ReadWriteLockType { struct ReaderWriterLockType {
enum State { enum State {
State_NotInitialized = 0, State_NotInitialized = 0,
State_Initialized = 1, State_Initialized = 1,
@ -65,6 +65,6 @@ namespace ams::os {
impl::InternalConditionVariableStorage _storage; impl::InternalConditionVariableStorage _storage;
} cv_write_lock; } cv_write_lock;
}; };
static_assert(std::is_trivial<ReadWriteLockType>::value); static_assert(std::is_trivial<ReaderWriterLockType>::value);
} }

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

@ -25,7 +25,7 @@ namespace ams::diag::impl {
private: private:
Holder *m_observer_list_head; Holder *m_observer_list_head;
Holder **m_observer_list_tail; Holder **m_observer_list_tail;
os::ReadWriteLock m_lock; os::ReaderWriterLock m_lock;
public: public:
constexpr ObserverManager() : m_observer_list_head(nullptr), m_observer_list_tail(std::addressof(m_observer_list_head)), m_lock() { 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() { void FileInterfaceAdapter::InvalidateCache() {
AMS_ABORT_UNLESS(this->parent_filesystem->IsDeepRetryEnabled()); 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); 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); AMS_ABORT_UNLESS(false);
} }
util::optional<std::shared_lock<os::ReadWriteLock>> FileSystemInterfaceAdapter::AcquireCacheInvalidationReadLock() { util::optional<std::shared_lock<os::ReaderWriterLock>> FileSystemInterfaceAdapter::AcquireCacheInvalidationReadLock() {
util::optional<std::shared_lock<os::ReadWriteLock>> lock; util::optional<std::shared_lock<os::ReaderWriterLock>> lock;
if (this->deep_retry_enabled) { if (this->deep_retry_enabled) {
lock.emplace(this->invalidation_lock); lock.emplace(this->invalidation_lock);
} }
return lock; return lock;
} }
os::ReadWriteLock &FileSystemInterfaceAdapter::GetReadWriteLockForCacheInvalidation() { os::ReaderWriterLock &FileSystemInterfaceAdapter::GetReaderWriterLockForCacheInvalidation() {
return this->invalidation_lock; 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::ReaderWriterLock>> StorageInterfaceAdapter::AcquireCacheInvalidationReadLock() {
util::optional<std::shared_lock<os::ReadWriteLock>> lock; util::optional<std::shared_lock<os::ReaderWriterLock>> lock;
if (this->deep_retry_enabled) { if (this->deep_retry_enabled) {
lock.emplace(this->invalidation_lock); 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. */ /* Get the thread local region. */
auto * const tlr = svc::GetThreadLocalRegion(); auto * const tlr = svc::GetThreadLocalRegion();
@ -152,7 +152,7 @@ namespace ams::os::impl {
} }
} }
void InternalReadWriteBusyMutexImpl::ReleaseReadLock() { void InternalReaderWriterBusyMutexImpl::ReleaseReadLock() {
/* Release the read lock. */ /* Release the read lock. */
{ {
/* Get pointer to our value. */ /* Get pointer to our value. */
@ -183,7 +183,7 @@ namespace ams::os::impl {
} }
} }
void InternalReadWriteBusyMutexImpl::AcquireWriteLock() { void InternalReaderWriterBusyMutexImpl::AcquireWriteLock() {
/* Get the thread local region. */ /* Get the thread local region. */
auto * const tlr = svc::GetThreadLocalRegion(); auto * const tlr = svc::GetThreadLocalRegion();
@ -247,7 +247,7 @@ namespace ams::os::impl {
} }
} }
void InternalReadWriteBusyMutexImpl::ReleaseWriteLock() { void InternalReaderWriterBusyMutexImpl::ReleaseWriteLock() {
/* Check pre-conditions. */ /* Check pre-conditions. */
AMS_ABORT_UNLESS(IsWriteLocked(m_value)); 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) #if defined(ATMOSPHERE_OS_HORIZON)
#include "os_rw_lock_target_impl.os.horizon.hpp" #include "os_rw_lock_target_impl.os.horizon.hpp"
#else #else
#error "Unknown OS for os::ReadWriteLockTargetImpl" #error "Unknown OS for os::ReaderWriterLockTargetImpl"
#endif #endif
namespace ams::os::impl { namespace ams::os::impl {
static_assert(alignof(ReadWriteLockType) == sizeof(u64) || alignof(ReadWriteLockType) == sizeof(u32)); static_assert(alignof(ReaderWriterLockType) == sizeof(u64) || alignof(ReaderWriterLockType) == sizeof(u32));
constexpr inline bool IsReadWriteLockGuaranteedAlignment = alignof(ReadWriteLockType) == sizeof(u64); constexpr inline bool IsReaderWriterLockGuaranteedAlignment = alignof(ReaderWriterLockType) == sizeof(u64);
struct ReadWriteLockCounter { struct ReaderWriterLockCounter {
using ReadLockCount = util::BitPack32::Field< 0, BITSIZEOF(u16) - 1, u32>; using ReadLockCount = util::BitPack32::Field< 0, BITSIZEOF(u16) - 1, u32>;
using WriteLocked = util::BitPack32::Field< ReadLockCount::Next, 1, u32>; using WriteLocked = util::BitPack32::Field< ReadLockCount::Next, 1, u32>;
using ReadLockWaiterCount = util::BitPack32::Field< WriteLocked::Next, BITSIZEOF(u8), u32>; using ReadLockWaiterCount = util::BitPack32::Field< WriteLocked::Next, BITSIZEOF(u8), u32>;
using WriteLockWaiterCount = util::BitPack32::Field<ReadLockWaiterCount::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) { ALWAYS_INLINE void ClearReadLockCount(ReaderWriterLockType::LockCount &lc) {
lc.counter.Set<ReadWriteLockCounter::ReadLockCount>(0); lc.counter.Set<ReaderWriterLockCounter::ReadLockCount>(0);
} }
ALWAYS_INLINE void ClearWriteLocked(ReadWriteLockType::LockCount &lc) { ALWAYS_INLINE void ClearWriteLocked(ReaderWriterLockType::LockCount &lc) {
lc.counter.Set<ReadWriteLockCounter::WriteLocked>(0); lc.counter.Set<ReaderWriterLockCounter::WriteLocked>(0);
} }
ALWAYS_INLINE void ClearReadLockWaiterCount(ReadWriteLockType::LockCount &lc) { ALWAYS_INLINE void ClearReadLockWaiterCount(ReaderWriterLockType::LockCount &lc) {
lc.counter.Set<ReadWriteLockCounter::ReadLockWaiterCount>(0); lc.counter.Set<ReaderWriterLockCounter::ReadLockWaiterCount>(0);
} }
ALWAYS_INLINE void ClearWriteLockWaiterCount(ReadWriteLockType::LockCount &lc) { ALWAYS_INLINE void ClearWriteLockWaiterCount(ReaderWriterLockType::LockCount &lc) {
lc.counter.Set<ReadWriteLockCounter::WriteLockWaiterCount>(0); lc.counter.Set<ReaderWriterLockCounter::WriteLockWaiterCount>(0);
} }
ALWAYS_INLINE void ClearWriteLockCount(ReadWriteLockType *rw_lock) { ALWAYS_INLINE void ClearWriteLockCount(ReaderWriterLockType *rw_lock) {
if constexpr (IsReadWriteLockGuaranteedAlignment) { if constexpr (IsReaderWriterLockGuaranteedAlignment) {
rw_lock->lock_count.aligned.write_lock_count = 0; rw_lock->lock_count.aligned.write_lock_count = 0;
} else { } else {
if (reinterpret_cast<uintptr_t>(std::addressof(rw_lock->lock_count)) & sizeof(u32)) { 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) { ALWAYS_INLINE ReaderWriterLockType::LockCount &GetLockCount(ReaderWriterLockType *rw_lock) {
if constexpr (IsReadWriteLockGuaranteedAlignment) { if constexpr (IsReaderWriterLockGuaranteedAlignment) {
return rw_lock->lock_count.aligned.c; return rw_lock->lock_count.aligned.c;
} else { } else {
if (reinterpret_cast<uintptr_t>(std::addressof(rw_lock->lock_count)) & sizeof(u32)) { 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) { ALWAYS_INLINE const ReaderWriterLockType::LockCount &GetLockCount(const ReaderWriterLockType *rw_lock) {
if constexpr (IsReadWriteLockGuaranteedAlignment) { if constexpr (IsReaderWriterLockGuaranteedAlignment) {
return rw_lock->lock_count.aligned.c; return rw_lock->lock_count.aligned.c;
} else { } else {
if (reinterpret_cast<uintptr_t>(std::addressof(rw_lock->lock_count)) & sizeof(u32)) { 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) { ALWAYS_INLINE u32 GetReadLockCount(const ReaderWriterLockType::LockCount &lc) {
return lc.counter.Get<ReadWriteLockCounter::ReadLockCount>(); return lc.counter.Get<ReaderWriterLockCounter::ReadLockCount>();
} }
ALWAYS_INLINE u32 GetWriteLocked(const ReadWriteLockType::LockCount &lc) { ALWAYS_INLINE u32 GetWriteLocked(const ReaderWriterLockType::LockCount &lc) {
return lc.counter.Get<ReadWriteLockCounter::WriteLocked>(); return lc.counter.Get<ReaderWriterLockCounter::WriteLocked>();
} }
ALWAYS_INLINE u32 GetReadLockWaiterCount(const ReadWriteLockType::LockCount &lc) { ALWAYS_INLINE u32 GetReadLockWaiterCount(const ReaderWriterLockType::LockCount &lc) {
return lc.counter.Get<ReadWriteLockCounter::ReadLockWaiterCount>(); return lc.counter.Get<ReaderWriterLockCounter::ReadLockWaiterCount>();
} }
ALWAYS_INLINE u32 GetWriteLockWaiterCount(const ReadWriteLockType::LockCount &lc) { ALWAYS_INLINE u32 GetWriteLockWaiterCount(const ReaderWriterLockType::LockCount &lc) {
return lc.counter.Get<ReadWriteLockCounter::WriteLockWaiterCount>(); return lc.counter.Get<ReaderWriterLockCounter::WriteLockWaiterCount>();
} }
ALWAYS_INLINE u32 &GetWriteLockCount(ReadWriteLockType &rw_lock) { ALWAYS_INLINE u32 &GetWriteLockCount(ReaderWriterLockType &rw_lock) {
if constexpr (IsReadWriteLockGuaranteedAlignment) { if constexpr (IsReaderWriterLockGuaranteedAlignment) {
return rw_lock.lock_count.aligned.write_lock_count; return rw_lock.lock_count.aligned.write_lock_count;
} else { } else {
if (reinterpret_cast<uintptr_t>(std::addressof(rw_lock.lock_count)) & sizeof(u32)) { 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) { ALWAYS_INLINE const u32 &GetWriteLockCount(const ReaderWriterLockType &rw_lock) {
if constexpr (IsReadWriteLockGuaranteedAlignment) { if constexpr (IsReaderWriterLockGuaranteedAlignment) {
return rw_lock.lock_count.aligned.write_lock_count; return rw_lock.lock_count.aligned.write_lock_count;
} else { } else {
if (reinterpret_cast<uintptr_t>(std::addressof(rw_lock.lock_count)) & sizeof(u32)) { 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) { ALWAYS_INLINE void IncReadLockCount(ReaderWriterLockType::LockCount &lc) {
const u32 read_lock_count = lc.counter.Get<ReadWriteLockCounter::ReadLockCount>(); const u32 read_lock_count = lc.counter.Get<ReaderWriterLockCounter::ReadLockCount>();
AMS_ASSERT(read_lock_count < ReadWriteLockCountMax); AMS_ASSERT(read_lock_count < ReaderWriterLockCountMax);
lc.counter.Set<ReadWriteLockCounter::ReadLockCount>(read_lock_count + 1); lc.counter.Set<ReaderWriterLockCounter::ReadLockCount>(read_lock_count + 1);
} }
ALWAYS_INLINE void DecReadLockCount(ReadWriteLockType::LockCount &lc) { ALWAYS_INLINE void DecReadLockCount(ReaderWriterLockType::LockCount &lc) {
const u32 read_lock_count = lc.counter.Get<ReadWriteLockCounter::ReadLockCount>(); const u32 read_lock_count = lc.counter.Get<ReaderWriterLockCounter::ReadLockCount>();
AMS_ASSERT(read_lock_count > 0); 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) { ALWAYS_INLINE void IncReadLockWaiterCount(ReaderWriterLockType::LockCount &lc) {
const u32 read_lock_waiter_count = lc.counter.Get<ReadWriteLockCounter::ReadLockWaiterCount>(); const u32 read_lock_waiter_count = lc.counter.Get<ReaderWriterLockCounter::ReadLockWaiterCount>();
AMS_ASSERT(read_lock_waiter_count < ReadWriteLockWaiterCountMax); AMS_ASSERT(read_lock_waiter_count < ReaderWriterLockWaiterCountMax);
lc.counter.Set<ReadWriteLockCounter::ReadLockWaiterCount>(read_lock_waiter_count + 1); lc.counter.Set<ReaderWriterLockCounter::ReadLockWaiterCount>(read_lock_waiter_count + 1);
} }
ALWAYS_INLINE void DecReadLockWaiterCount(ReadWriteLockType::LockCount &lc) { ALWAYS_INLINE void DecReadLockWaiterCount(ReaderWriterLockType::LockCount &lc) {
const u32 read_lock_waiter_count = lc.counter.Get<ReadWriteLockCounter::ReadLockWaiterCount>(); const u32 read_lock_waiter_count = lc.counter.Get<ReaderWriterLockCounter::ReadLockWaiterCount>();
AMS_ASSERT(read_lock_waiter_count > 0); 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) { ALWAYS_INLINE void IncWriteLockWaiterCount(ReaderWriterLockType::LockCount &lc) {
const u32 write_lock_waiter_count = lc.counter.Get<ReadWriteLockCounter::WriteLockWaiterCount>(); const u32 write_lock_waiter_count = lc.counter.Get<ReaderWriterLockCounter::WriteLockWaiterCount>();
AMS_ASSERT(write_lock_waiter_count < ReadWriteLockWaiterCountMax); AMS_ASSERT(write_lock_waiter_count < ReaderWriterLockWaiterCountMax);
lc.counter.Set<ReadWriteLockCounter::WriteLockWaiterCount>(write_lock_waiter_count + 1); lc.counter.Set<ReaderWriterLockCounter::WriteLockWaiterCount>(write_lock_waiter_count + 1);
} }
ALWAYS_INLINE void DecWriteLockWaiterCount(ReadWriteLockType::LockCount &lc) { ALWAYS_INLINE void DecWriteLockWaiterCount(ReaderWriterLockType::LockCount &lc) {
const u32 write_lock_waiter_count = lc.counter.Get<ReadWriteLockCounter::WriteLockWaiterCount>(); const u32 write_lock_waiter_count = lc.counter.Get<ReaderWriterLockCounter::WriteLockWaiterCount>();
AMS_ASSERT(write_lock_waiter_count > 0); 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); u32 &write_lock_count = GetWriteLockCount(rw_lock);
AMS_ASSERT(write_lock_count < ReadWriteLockCountMax); AMS_ASSERT(write_lock_count < ReaderWriterLockCountMax);
++write_lock_count; ++write_lock_count;
} }
ALWAYS_INLINE void DecWriteLockCount(ReadWriteLockType &rw_lock) { ALWAYS_INLINE void DecWriteLockCount(ReaderWriterLockType &rw_lock) {
u32 &write_lock_count = GetWriteLockCount(rw_lock); u32 &write_lock_count = GetWriteLockCount(rw_lock);
AMS_ASSERT(write_lock_count > 0); AMS_ASSERT(write_lock_count > 0);
--write_lock_count; --write_lock_count;
} }
ALWAYS_INLINE void SetWriteLocked(ReadWriteLockType::LockCount &lc) { ALWAYS_INLINE void SetWriteLocked(ReaderWriterLockType::LockCount &lc) {
lc.counter.Set<ReadWriteLockCounter::WriteLocked>(1); 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)) (__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(GetWriteLocked(GetLockCount(rw_lock)) == 1);
AMS_ASSERT((GetThreadHandle(GetLockCount(rw_lock)) | svc::HandleWaitMask) == (impl::GetCurrentThreadHandle() | svc::HandleWaitMask)); AMS_ASSERT((GetThreadHandle(GetLockCount(rw_lock)) | svc::HandleWaitMask) == (impl::GetCurrentThreadHandle() | svc::HandleWaitMask));
alignas(alignof(u64)) LockCount expected = GetLockCount(rw_lock); 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)); } 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(GetWriteLocked(GetLockCount(rw_lock)) == 1);
AMS_ASSERT((GetThreadHandle(GetLockCount(rw_lock)) | svc::HandleWaitMask) == (impl::GetCurrentThreadHandle() | svc::HandleWaitMask)); AMS_ASSERT((GetThreadHandle(GetLockCount(rw_lock)) | svc::HandleWaitMask) == (impl::GetCurrentThreadHandle() | svc::HandleWaitMask));
alignas(alignof(u64)) LockCount expected = GetLockCount(rw_lock); alignas(alignof(u64)) LockCount expected = GetLockCount(rw_lock);
@ -46,7 +46,7 @@ namespace ams::os::impl {
return ReleaseWriteLockImpl(rw_lock); 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 expected = GetLockCount(rw_lock);
alignas(alignof(u64)) LockCount lock_count = expected; alignas(alignof(u64)) LockCount lock_count = expected;
AMS_ASSERT(GetWriteLocked(lock_count) == 1); 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); AMS_ASSERT(::ams::svc::GetThreadLocalRegion()->disable_count == 0);
auto *cur_thread = impl::GetCurrentThread(); 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); AMS_ASSERT(::ams::svc::GetThreadLocalRegion()->disable_count == 0);
auto *cur_thread = impl::GetCurrentThread(); 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(::ams::svc::GetThreadLocalRegion()->disable_count == 0);
AMS_ASSERT(GetReadLockCount(GetLockCount(rw_lock)) > 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); AMS_ASSERT(::ams::svc::GetThreadLocalRegion()->disable_count == 0);
auto *cur_thread = impl::GetCurrentThread(); 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); AMS_ASSERT(::ams::svc::GetThreadLocalRegion()->disable_count == 0);
auto *cur_thread = impl::GetCurrentThread(); 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(::ams::svc::GetThreadLocalRegion()->disable_count == 0);
AMS_ASSERT(GetWriteLockCount(*rw_lock) > 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 { namespace ams::os::impl {
class ReadWriteLockHorizonImpl { class ReaderWriterLockHorizonImpl {
private: private:
using LockCount = os::ReadWriteLockType::LockCount; using LockCount = os::ReaderWriterLockType::LockCount;
private: private:
static ALWAYS_INLINE u32 GetThreadHandle(const LockCount &lc) { static ALWAYS_INLINE u32 GetThreadHandle(const LockCount &lc) {
return GetReference(lc.cs_storage).Get()->thread_handle; return GetReference(lc.cs_storage).Get()->thread_handle;
@ -34,19 +34,19 @@ namespace ams::os::impl {
GetReference(lc.cs_storage).Get()->thread_handle = handle; GetReference(lc.cs_storage).Get()->thread_handle = handle;
} }
static void AcquireReadLockWriteLocked(os::ReadWriteLockType *rw_lock); static void AcquireReadLockWriteLocked(os::ReaderWriterLockType *rw_lock);
static void ReleaseReadLockWriteLocked(os::ReadWriteLockType *rw_lock); static void ReleaseReadLockWriteLocked(os::ReaderWriterLockType *rw_lock);
static void ReleaseWriteLockImpl(os::ReadWriteLockType *rw_lock); static void ReleaseWriteLockImpl(os::ReaderWriterLockType *rw_lock);
public: public:
static void AcquireReadLock(os::ReadWriteLockType *rw_lock); static void AcquireReadLock(os::ReaderWriterLockType *rw_lock);
static bool TryAcquireReadLock(os::ReadWriteLockType *rw_lock); static bool TryAcquireReadLock(os::ReaderWriterLockType *rw_lock);
static void ReleaseReadLock(os::ReadWriteLockType *rw_lock); static void ReleaseReadLock(os::ReaderWriterLockType *rw_lock);
static void AcquireWriteLock(os::ReadWriteLockType *rw_lock); static void AcquireWriteLock(os::ReaderWriterLockType *rw_lock);
static bool TryAcquireWriteLock(os::ReadWriteLockType *rw_lock); static bool TryAcquireWriteLock(os::ReaderWriterLockType *rw_lock);
static void ReleaseWriteLock(os::ReadWriteLockType *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) #if defined(ATMOSPHERE_OS_HORIZON)
#include "impl/os_internal_rw_busy_mutex_impl.os.horizon.hpp" #include "impl/os_internal_rw_busy_mutex_impl.os.horizon.hpp"
#else #else
#error "Unknown OS for ams::os::impl::InternalReadWriteBusyMutexImpl" #error "Unknown OS for ams::os::impl::InternalReaderWriterBusyMutexImpl"
#endif #endif
namespace ams::os { namespace ams::os {
void InitalizeReadWriteLockBusyMutex(ReadWriteBusyMutexType *rw_mutex) { void InitalizeReaderWriterLockBusyMutex(ReaderWriterBusyMutexType *rw_mutex) {
/* Create object. */ /* Create object. */
util::ConstructAt(rw_mutex->_storage); util::ConstructAt(rw_mutex->_storage);
} }
void AcquireReadLockBusyMutex(ReadWriteBusyMutexType *rw_mutex) { void AcquireReadLockBusyMutex(ReaderWriterBusyMutexType *rw_mutex) {
/* Acquire read lock. */ /* Acquire read lock. */
util::GetReference(rw_mutex->_storage).AcquireReadLock(); util::GetReference(rw_mutex->_storage).AcquireReadLock();
} }
void ReleaseReadLockBusyMutex(ReadWriteBusyMutexType *rw_mutex) { void ReleaseReadLockBusyMutex(ReaderWriterBusyMutexType *rw_mutex) {
/* Release read lock. */ /* Release read lock. */
util::GetReference(rw_mutex->_storage).ReleaseReadLock(); util::GetReference(rw_mutex->_storage).ReleaseReadLock();
} }
void AcquireWriteLockBusyMutex(ReadWriteBusyMutexType *rw_mutex) { void AcquireWriteLockBusyMutex(ReaderWriterBusyMutexType *rw_mutex) {
/* Acquire write lock. */ /* Acquire write lock. */
util::GetReference(rw_mutex->_storage).AcquireWriteLock(); util::GetReference(rw_mutex->_storage).AcquireWriteLock();
} }
void ReleaseWriteLockBusyMutex(ReadWriteBusyMutexType *rw_mutex) { void ReleaseWriteLockBusyMutex(ReaderWriterBusyMutexType *rw_mutex) {
/* Release write lock. */ /* Release write lock. */
util::GetReference(rw_mutex->_storage).ReleaseWriteLock(); util::GetReference(rw_mutex->_storage).ReleaseWriteLock();
} }

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

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