mika/Atmosphere-libs
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere-libs.git synced 2025-08-06 23:49:29 +02:00
Code Issues Packages Projects Releases Wiki Activity

stratosphere: use SdkMutex/SdkRecursiveMutex over Mutex

Browse Source
This commit is contained in:
Michael Scire 2021-09-29 22:52:50 -07:00
parent 6fdac55fd1
commit c68298a00e
48 changed files with 107 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libstratosphere/include/stratosphere/fs/common/fs_file_storage.hpp
View File

@ -92,9 +92,9 @@ namespace ams::fs {
FileHandle handle; FileHandle handle;
bool close_file; bool close_file;
s64 size; s64 size;
os::Mutex mutex; os::SdkMutex mutex;
public: public:
constexpr explicit FileHandleStorage(FileHandle handle, bool close_file) : handle(handle), close_file(close_file), size(InvalidSize), mutex(false) { /* ... */ } constexpr explicit FileHandleStorage(FileHandle handle, bool close_file) : handle(handle), close_file(close_file), size(InvalidSize), mutex() { /* ... */ }
constexpr explicit FileHandleStorage(FileHandle handle) : FileHandleStorage(handle, false) { /* ... */ } constexpr explicit FileHandleStorage(FileHandle handle) : FileHandleStorage(handle, false) { /* ... */ }
virtual ~FileHandleStorage() override { virtual ~FileHandleStorage() override {

6
libstratosphere/include/stratosphere/fssrv/fssrv_memory_resource_from_exp_heap.hpp
View File

@ -42,11 +42,11 @@ namespace ams::fssrv {
class PeakCheckableMemoryResourceFromExpHeap : public ams::MemoryResource { class PeakCheckableMemoryResourceFromExpHeap : public ams::MemoryResource {
private: private:
lmem::HeapHandle heap_handle; lmem::HeapHandle heap_handle;
os::Mutex mutex; os::SdkMutex mutex;
size_t peak_free_size; size_t peak_free_size;
size_t current_free_size; size_t current_free_size;
public: public:
constexpr explicit PeakCheckableMemoryResourceFromExpHeap(size_t heap_size) : heap_handle(nullptr), mutex(false), peak_free_size(heap_size), current_free_size(heap_size) { /* ... */ } constexpr explicit PeakCheckableMemoryResourceFromExpHeap(size_t heap_size) : heap_handle(nullptr), mutex(), peak_free_size(heap_size), current_free_size(heap_size) { /* ... */ }
void SetHeapHandle(lmem::HeapHandle handle) { void SetHeapHandle(lmem::HeapHandle handle) {
this->heap_handle = handle; this->heap_handle = handle;
@ -57,7 +57,7 @@ namespace ams::fssrv {
void ClearPeak() { this->peak_free_size = this->current_free_size; } void ClearPeak() { this->peak_free_size = this->current_free_size; }
std::scoped_lock<os::Mutex> GetScopedLock() { std::scoped_lock<os::SdkMutex> GetScopedLock() {
return std::scoped_lock(this->mutex); return std::scoped_lock(this->mutex);
} }

4
libstratosphere/include/stratosphere/fssystem/buffers/fssystem_file_system_buffer_manager.hpp
View File

@ -192,7 +192,7 @@ namespace ams::fssystem {
size_t peak_free_size; size_t peak_free_size;
size_t peak_total_allocatable_size; size_t peak_total_allocatable_size;
size_t retried_count; size_t retried_count;
mutable os::Mutex mutex; mutable os::SdkRecursiveMutex mutex;
public: public:
static constexpr size_t QueryWorkBufferSize(s32 max_cache_count, s32 max_order) { static constexpr size_t QueryWorkBufferSize(s32 max_cache_count, s32 max_order) {
const auto buddy_size = FileSystemBuddyHeap::QueryWorkBufferSize(max_order); const auto buddy_size = FileSystemBuddyHeap::QueryWorkBufferSize(max_order);
@ -200,7 +200,7 @@ namespace ams::fssystem {
return buddy_size + table_size; return buddy_size + table_size;
} }
public: public:
FileSystemBufferManager() : total_size(), peak_free_size(), peak_total_allocatable_size(), retried_count(), mutex(true) { /* ... */ } FileSystemBufferManager() : total_size(), peak_free_size(), peak_total_allocatable_size(), retried_count(), mutex() { /* ... */ }
virtual ~FileSystemBufferManager() { /* ... */ } virtual ~FileSystemBufferManager() { /* ... */ }

2
libstratosphere/include/stratosphere/fssystem/fssystem_aes_xts_storage.hpp
View File

@ -33,7 +33,7 @@ namespace ams::fssystem {
char key[2][KeySize]; char key[2][KeySize];
char iv[IvSize]; char iv[IvSize];
const size_t block_size; const size_t block_size;
os::Mutex mutex; os::SdkMutex mutex;
public: public:
AesXtsStorage(IStorage *base, const void *key1, const void *key2, size_t key_size, const void *iv, size_t iv_size, size_t block_size); AesXtsStorage(IStorage *base, const void *key1, const void *key2, size_t key_size, const void *iv, size_t iv_size, size_t block_size);

2
libstratosphere/include/stratosphere/fssystem/fssystem_directory_redirection_filesystem.hpp
View File

@ -34,7 +34,7 @@ namespace ams::fssystem {
virtual ~DirectoryRedirectionFileSystem(); virtual ~DirectoryRedirectionFileSystem();
protected: protected:
inline util::optional<std::scoped_lock<os::Mutex>> GetAccessorLock() const { inline util::optional<std::scoped_lock<os::SdkMutex>> GetAccessorLock() const {
/* No accessor lock is needed. */ /* No accessor lock is needed. */
return util::nullopt; return util::nullopt;
} }

6
libstratosphere/include/stratosphere/fssystem/fssystem_directory_savedata_filesystem.hpp
View File

@ -24,7 +24,7 @@ namespace ams::fssystem {
using PathResolutionFileSystem = impl::IPathResolutionFileSystem<DirectorySaveDataFileSystem>; using PathResolutionFileSystem = impl::IPathResolutionFileSystem<DirectorySaveDataFileSystem>;
friend class impl::IPathResolutionFileSystem<DirectorySaveDataFileSystem>; friend class impl::IPathResolutionFileSystem<DirectorySaveDataFileSystem>;
private: private:
os::Mutex accessor_mutex; os::SdkMutex accessor_mutex;
s32 open_writable_files; s32 open_writable_files;
public: public:
DirectorySaveDataFileSystem(std::shared_ptr<fs::fsa::IFileSystem> fs); DirectorySaveDataFileSystem(std::shared_ptr<fs::fsa::IFileSystem> fs);
@ -33,9 +33,9 @@ namespace ams::fssystem {
virtual ~DirectorySaveDataFileSystem(); virtual ~DirectorySaveDataFileSystem();
protected: protected:
inline util::optional<std::scoped_lock<os::Mutex>> GetAccessorLock() { inline util::optional<std::scoped_lock<os::SdkMutex>> GetAccessorLock() {
/* We have a real accessor lock that we want to use. */ /* We have a real accessor lock that we want to use. */
return util::make_optional<std::scoped_lock<os::Mutex>>(this->accessor_mutex); return util::make_optional<std::scoped_lock<os::SdkMutex>>(this->accessor_mutex);
} }
private: private:
Result AllocateWorkBuffer(std::unique_ptr<u8[]> *out, size_t *out_size, size_t ideal_size); Result AllocateWorkBuffer(std::unique_ptr<u8[]> *out, size_t *out_size, size_t ideal_size);

4
libstratosphere/include/stratosphere/fssystem/fssystem_integrity_romfs_storage.hpp
View File

@ -30,11 +30,11 @@ namespace ams::fssystem {
private: private:
save::HierarchicalIntegrityVerificationStorage integrity_storage; save::HierarchicalIntegrityVerificationStorage integrity_storage;
save::FileSystemBufferManagerSet buffers; save::FileSystemBufferManagerSet buffers;
os::Mutex mutex; os::SdkRecursiveMutex mutex;
Hash master_hash; Hash master_hash;
std::unique_ptr<fs::MemoryStorage> master_hash_storage; std::unique_ptr<fs::MemoryStorage> master_hash_storage;
public: public:
IntegrityRomFsStorage() : mutex(true) { /* ... */ } IntegrityRomFsStorage() : mutex() { /* ... */ }
virtual ~IntegrityRomFsStorage() override { this->Finalize(); } virtual ~IntegrityRomFsStorage() override { this->Finalize(); }
Result Initialize(save::HierarchicalIntegrityVerificationInformation level_hash_info, Hash master_hash, save::HierarchicalIntegrityVerificationStorage::HierarchicalStorageInformation storage_info, IBufferManager *bm); Result Initialize(save::HierarchicalIntegrityVerificationInformation level_hash_info, Hash master_hash, save::HierarchicalIntegrityVerificationStorage::HierarchicalStorageInformation storage_info, IBufferManager *bm);

2
libstratosphere/include/stratosphere/fssystem/fssystem_subdirectory_filesystem.hpp
View File

@ -32,7 +32,7 @@ namespace ams::fssystem {
virtual ~SubDirectoryFileSystem(); virtual ~SubDirectoryFileSystem();
protected: protected:
inline util::optional<std::scoped_lock<os::Mutex>> GetAccessorLock() const { inline util::optional<std::scoped_lock<os::SdkMutex>> GetAccessorLock() const {
/* No accessor lock is needed. */ /* No accessor lock is needed. */
return util::nullopt; return util::nullopt;
} }

4
libstratosphere/include/stratosphere/fssystem/save/fssystem_block_cache_buffered_storage.hpp
View File

@ -62,7 +62,7 @@ namespace ams::fssystem::save {
}; };
private: private:
IBufferManager *buffer_manager; IBufferManager *buffer_manager;
os::Mutex *mutex; os::SdkRecursiveMutex *mutex;
std::unique_ptr<CacheEntry[], ::ams::fs::impl::Deleter> entries; std::unique_ptr<CacheEntry[], ::ams::fs::impl::Deleter> entries;
IStorage *data_storage; IStorage *data_storage;
Result last_result; Result last_result;
@ -78,7 +78,7 @@ namespace ams::fssystem::save {
BlockCacheBufferedStorage(); BlockCacheBufferedStorage();
virtual ~BlockCacheBufferedStorage() override; virtual ~BlockCacheBufferedStorage() override;
Result Initialize(IBufferManager *bm, os::Mutex *mtx, IStorage *data, s64 data_size, size_t verif_block_size, s32 max_cache_entries, bool is_real_data, s8 buffer_level, bool is_keep_burst_mode, fs::StorageType storage_type); Result Initialize(IBufferManager *bm, os::SdkRecursiveMutex *mtx, IStorage *data, s64 data_size, size_t verif_block_size, s32 max_cache_entries, bool is_real_data, s8 buffer_level, bool is_keep_burst_mode, fs::StorageType storage_type);
void Finalize(); void Finalize();
virtual Result Read(s64 offset, void *buffer, size_t size) override; virtual Result Read(s64 offset, void *buffer, size_t size) override;

2
libstratosphere/include/stratosphere/fssystem/save/fssystem_buffered_storage.hpp
View File

@ -38,7 +38,7 @@ namespace ams::fssystem::save {
s32 cache_count; s32 cache_count;
Cache *next_acquire_cache; Cache *next_acquire_cache;
Cache *next_fetch_cache; Cache *next_fetch_cache;
os::Mutex mutex; os::SdkMutex mutex;
bool bulk_read_enabled; bool bulk_read_enabled;
public: public:
BufferedStorage(); BufferedStorage();

4
libstratosphere/include/stratosphere/fssystem/save/fssystem_hierarchical_integrity_verification_storage.hpp
View File

@ -147,7 +147,7 @@ namespace ams::fssystem::save {
} }
private: private:
FileSystemBufferManagerSet *buffers; FileSystemBufferManagerSet *buffers;
os::Mutex *mutex; os::SdkRecursiveMutex *mutex;
IntegrityVerificationStorage verify_storages[MaxLayers - 1]; IntegrityVerificationStorage verify_storages[MaxLayers - 1];
BlockCacheBufferedStorage buffer_storages[MaxLayers - 1]; BlockCacheBufferedStorage buffer_storages[MaxLayers - 1];
s64 data_size; s64 data_size;
@ -157,7 +157,7 @@ namespace ams::fssystem::save {
HierarchicalIntegrityVerificationStorage() : buffers(nullptr), mutex(nullptr), data_size(-1), is_written_for_rollback(false) { /* ... */ } HierarchicalIntegrityVerificationStorage() : buffers(nullptr), mutex(nullptr), data_size(-1), is_written_for_rollback(false) { /* ... */ }
virtual ~HierarchicalIntegrityVerificationStorage() override { this->Finalize(); } virtual ~HierarchicalIntegrityVerificationStorage() override { this->Finalize(); }
Result Initialize(const HierarchicalIntegrityVerificationInformation &info, HierarchicalStorageInformation storage, FileSystemBufferManagerSet *bufs, os::Mutex *mtx, fs::StorageType storage_type); Result Initialize(const HierarchicalIntegrityVerificationInformation &info, HierarchicalStorageInformation storage, FileSystemBufferManagerSet *bufs, os::SdkRecursiveMutex *mtx, fs::StorageType storage_type);
void Finalize(); void Finalize();
virtual Result Read(s64 offset, void *buffer, size_t size) override; virtual Result Read(s64 offset, void *buffer, size_t size) override;

4
libstratosphere/include/stratosphere/kvdb/kvdb_file_key_value_store.hpp
View File

@ -63,14 +63,14 @@ namespace ams::kvdb {
bool Contains(const void *key, size_t key_size); bool Contains(const void *key, size_t key_size);
}; };
private: private:
os::Mutex lock; os::SdkMutex lock;
Path dir_path; Path dir_path;
Cache cache; Cache cache;
private: private:
Path GetPath(const void *key, size_t key_size); Path GetPath(const void *key, size_t key_size);
Result GetKey(size_t *out_size, void *out_key, size_t max_out_size, const FileName &file_name); Result GetKey(size_t *out_size, void *out_key, size_t max_out_size, const FileName &file_name);
public: public:
FileKeyValueStore() : lock(false) { /* ... */ } FileKeyValueStore() : lock() { /* ... */ }
/* Basic accessors. */ /* Basic accessors. */
Result Initialize(const char *dir); Result Initialize(const char *dir);

2
libstratosphere/include/stratosphere/lmem/impl/lmem_impl_common.hpp
View File

@ -85,7 +85,7 @@ namespace ams::lmem::impl {
void *heap_start; void *heap_start;
void *heap_end; void *heap_end;
os::MutexType mutex; os::SdkMutexType mutex;
u8 option; u8 option;
ImplementationHeapHead impl_head; ImplementationHeapHead impl_head;
}; };

2
libstratosphere/include/stratosphere/lr/lr_location_resolver_manager_impl.hpp
View File

@ -28,7 +28,7 @@ namespace ams::lr {
sf::SharedPointer<IRegisteredLocationResolver> registered_location_resolver = nullptr; sf::SharedPointer<IRegisteredLocationResolver> registered_location_resolver = nullptr;
sf::SharedPointer<IAddOnContentLocationResolver> add_on_content_location_resolver = nullptr; sf::SharedPointer<IAddOnContentLocationResolver> add_on_content_location_resolver = nullptr;
os::Mutex mutex{false}; os::SdkMutex mutex{};
public: public:
/* Actual commands. */ /* Actual commands. */
Result OpenLocationResolver(sf::Out<sf::SharedPointer<ILocationResolver>> out, ncm::StorageId storage_id); Result OpenLocationResolver(sf::Out<sf::SharedPointer<ILocationResolver>> out, ncm::StorageId storage_id);

6
libstratosphere/include/stratosphere/ncm/ncm_content_manager_impl.hpp
View File

@ -102,7 +102,7 @@ namespace ams::ncm {
ContentMetaDatabaseRoot() { /* ... */ } ContentMetaDatabaseRoot() { /* ... */ }
}; };
private: private:
os::Mutex mutex; os::SdkRecursiveMutex mutex;
bool initialized; bool initialized;
ContentStorageRoot content_storage_roots[MaxContentStorageRoots]; ContentStorageRoot content_storage_roots[MaxContentStorageRoots];
ContentMetaDatabaseRoot content_meta_database_roots[MaxContentMetaDatabaseRoots]; ContentMetaDatabaseRoot content_meta_database_roots[MaxContentMetaDatabaseRoots];
@ -111,8 +111,8 @@ namespace ams::ncm {
RightsIdCache rights_id_cache; RightsIdCache rights_id_cache;
RegisteredHostContent registered_host_content; RegisteredHostContent registered_host_content;
public: public:
ContentManagerImpl() : mutex(true), initialized(false), num_content_storage_entries(0), num_content_meta_entries(0), rights_id_cache(), registered_host_content() { ContentManagerImpl() : mutex(), initialized(false), num_content_storage_entries(0), num_content_meta_entries(0), rights_id_cache(), registered_host_content() {
/* ... */ /* ... */
}; };
~ContentManagerImpl(); ~ContentManagerImpl();
public: public:

8
libstratosphere/include/stratosphere/ncm/ncm_install_task_base.hpp
View File

@ -86,13 +86,13 @@ namespace ams::ncm {
StorageId install_storage; StorageId install_storage;
InstallTaskDataBase *data; InstallTaskDataBase *data;
InstallProgress progress; InstallProgress progress;
os::Mutex progress_mutex; os::SdkMutex progress_mutex;
u32 config; u32 config;
os::Mutex cancel_mutex; os::SdkMutex cancel_mutex;
bool cancel_requested; bool cancel_requested;
InstallThroughput throughput; InstallThroughput throughput;
TimeSpan throughput_start_time; TimeSpan throughput_start_time;
os::Mutex throughput_mutex; os::SdkMutex throughput_mutex;
FirmwareVariationId firmware_variation_id; FirmwareVariationId firmware_variation_id;
private: private:
ALWAYS_INLINE Result SetLastResultOnFailure(Result result) { ALWAYS_INLINE Result SetLastResultOnFailure(Result result) {
@ -102,7 +102,7 @@ namespace ams::ncm {
return result; return result;
} }
public: public:
InstallTaskBase() : data(), progress(), progress_mutex(false), cancel_mutex(false), cancel_requested(), throughput_mutex(false) { /* ... */ } InstallTaskBase() : data(), progress(), progress_mutex(), cancel_mutex(), cancel_requested(), throughput_mutex() { /* ... */ }
virtual ~InstallTaskBase() { /* ... */ }; virtual ~InstallTaskBase() { /* ... */ };
public: public:
virtual void Cancel(); virtual void Cancel();

4
libstratosphere/include/stratosphere/ncm/ncm_memory_report.hpp
View File

@ -40,13 +40,13 @@ namespace ams::ncm {
class HeapState { class HeapState {
private: private:
os::Mutex mutex; os::SdkMutex mutex;
lmem::HeapHandle heap_handle; lmem::HeapHandle heap_handle;
size_t total_alloc_size; size_t total_alloc_size;
size_t peak_total_alloc_size; size_t peak_total_alloc_size;
size_t peak_alloc_size; size_t peak_alloc_size;
public: public:
constexpr HeapState() : mutex(false), heap_handle(nullptr), total_alloc_size(0), peak_total_alloc_size(0), peak_alloc_size(0) { /* ... */ } constexpr HeapState() : mutex(), heap_handle(nullptr), total_alloc_size(0), peak_total_alloc_size(0), peak_alloc_size(0) { /* ... */ }
void Initialize(lmem::HeapHandle heap_handle); void Initialize(lmem::HeapHandle heap_handle);
void Allocate(size_t size); void Allocate(size_t size);

6
libstratosphere/include/stratosphere/sf/cmif/sf_cmif_domain_manager.hpp
View File

@ -84,7 +84,7 @@ namespace ams::sf::cmif {
private: private:
using EntryList = typename util::IntrusiveListMemberTraits<&Entry::free_list_node>::ListType; using EntryList = typename util::IntrusiveListMemberTraits<&Entry::free_list_node>::ListType;
private: private:
os::Mutex lock; os::SdkMutex lock;
EntryList free_list; EntryList free_list;
Entry *entries; Entry *entries;
size_t num_entries; size_t num_entries;
@ -114,13 +114,13 @@ namespace ams::sf::cmif {
} }
}; };
private: private:
os::Mutex entry_owner_lock; os::SdkMutex entry_owner_lock;
EntryManager entry_manager; EntryManager entry_manager;
private: private:
virtual void *AllocateDomain() = 0; virtual void *AllocateDomain() = 0;
virtual void FreeDomain(void *) = 0; virtual void FreeDomain(void *) = 0;
protected: protected:
ServerDomainManager(DomainEntryStorage *entry_storage, size_t entry_count) : entry_owner_lock(false), entry_manager(entry_storage, entry_count) { /* ... */ } ServerDomainManager(DomainEntryStorage *entry_storage, size_t entry_count) : entry_owner_lock(), entry_manager(entry_storage, entry_count) { /* ... */ }
inline DomainServiceObject *AllocateDomainServiceObject() { inline DomainServiceObject *AllocateDomainServiceObject() {
void *storage = this->AllocateDomain(); void *storage = this->AllocateDomain();

10
libstratosphere/include/stratosphere/sf/hipc/sf_hipc_server_manager.hpp
View File

@ -80,9 +80,9 @@ namespace ams::sf::hipc {
os::Event notify_event; os::Event notify_event;
os::WaitableHolderType notify_event_holder; os::WaitableHolderType notify_event_holder;
os::Mutex waitable_selection_mutex; os::SdkMutex waitable_selection_mutex;
os::Mutex waitlist_mutex; os::SdkMutex waitlist_mutex;
os::WaitableManagerType waitlist; os::WaitableManagerType waitlist;
private: private:
virtual void RegisterSessionToWaitList(ServerSession *session) override final; virtual void RegisterSessionToWaitList(ServerSession *session) override final;
@ -192,7 +192,7 @@ namespace ams::sf::hipc {
ServerManagerBase(DomainEntryStorage *entry_storage, size_t entry_count) : ServerManagerBase(DomainEntryStorage *entry_storage, size_t entry_count) :
ServerDomainSessionManager(entry_storage, entry_count), ServerDomainSessionManager(entry_storage, entry_count),
request_stop_event(os::EventClearMode_ManualClear), notify_event(os::EventClearMode_ManualClear), request_stop_event(os::EventClearMode_ManualClear), notify_event(os::EventClearMode_ManualClear),
waitable_selection_mutex(false), waitlist_mutex(false) waitable_selection_mutex(), waitlist_mutex()
{ {
/* Link waitables. */ /* Link waitables. */
os::InitializeWaitableManager(std::addressof(this->waitable_manager)); os::InitializeWaitableManager(std::addressof(this->waitable_manager));
@ -259,7 +259,7 @@ namespace ams::sf::hipc {
using ServerManagerBase::DomainStorage; using ServerManagerBase::DomainStorage;
private: private:
/* Resource storage. */ /* Resource storage. */
os::Mutex resource_mutex; os::SdkMutex resource_mutex;
util::TypedStorage<Server> server_storages[MaxServers]; util::TypedStorage<Server> server_storages[MaxServers];
bool server_allocated[MaxServers]; bool server_allocated[MaxServers];
util::TypedStorage<ServerSession> session_storages[MaxSessions]; util::TypedStorage<ServerSession> session_storages[MaxSessions];
@ -370,7 +370,7 @@ namespace ams::sf::hipc {
return this->GetObjectBySessionIndex(session, this->saved_messages_start, hipc::TlsMessageBufferSize); return this->GetObjectBySessionIndex(session, this->saved_messages_start, hipc::TlsMessageBufferSize);
} }
public: public:
ServerManager() : ServerManagerBase(this->domain_entry_storages, ManagerOptions::MaxDomainObjects), resource_mutex(false) { ServerManager() : ServerManagerBase(this->domain_entry_storages, ManagerOptions::MaxDomainObjects), resource_mutex() {
/* Clear storages. */ /* Clear storages. */
#define SF_SM_MEMCLEAR(obj) if constexpr (sizeof(obj) > 0) { std::memset(obj, 0, sizeof(obj)); } #define SF_SM_MEMCLEAR(obj) if constexpr (sizeof(obj) > 0) { std::memset(obj, 0, sizeof(obj)); }
SF_SM_MEMCLEAR(this->server_storages); SF_SM_MEMCLEAR(this->server_storages);

6
libstratosphere/include/stratosphere/tipc/tipc_server_manager.hpp
View File

@ -355,7 +355,7 @@ namespace ams::tipc {
using PortAllocatorTuple = std::tuple<typename PortInfos::Allocator...>; using PortAllocatorTuple = std::tuple<typename PortInfos::Allocator...>;
private: private:
os::Mutex m_mutex; os::SdkRecursiveMutex m_mutex;
os::TlsSlot m_tls_slot; os::TlsSlot m_tls_slot;
PortManagerTuple m_port_managers; PortManagerTuple m_port_managers;
PortAllocatorTuple m_port_allocators; PortAllocatorTuple m_port_allocators;
@ -390,11 +390,11 @@ namespace ams::tipc {
os::StartThread(m_port_threads + Ix); os::StartThread(m_port_threads + Ix);
} }
public: public:
ServerManagerImpl() : m_mutex(true), m_tls_slot(), m_port_managers(), m_port_allocators() { /* ... */ } ServerManagerImpl() : m_mutex(), m_tls_slot(), m_port_managers(), m_port_allocators() { /* ... */ }
os::TlsSlot GetTlsSlot() const { return m_tls_slot; } os::TlsSlot GetTlsSlot() const { return m_tls_slot; }
os::Mutex &GetMutex() { return m_mutex; } os::SdkRecursiveMutex &GetMutex() { return m_mutex; }
void Initialize() { void Initialize() {
/* Initialize our tls slot. */ /* Initialize our tls slot. */

8
libstratosphere/source/cfg/cfg_privileged_process.cpp
View File

@ -24,10 +24,10 @@ namespace ams::cfg {
constexpr os::ProcessId InitialProcessIdMaxDeprecated = {0x50}; constexpr os::ProcessId InitialProcessIdMaxDeprecated = {0x50};
/* Privileged process globals. */ /* Privileged process globals. */
os::Mutex g_lock(false); constinit os::SdkMutex g_lock;
bool g_got_privileged_process_status = false; constinit bool g_got_privileged_process_status = false;
os::ProcessId g_min_initial_process_id = os::InvalidProcessId, g_max_initial_process_id = os::InvalidProcessId; constinit os::ProcessId g_min_initial_process_id = os::InvalidProcessId, g_max_initial_process_id = os::InvalidProcessId;
os::ProcessId g_cur_process_id = os::InvalidProcessId; constinit os::ProcessId g_cur_process_id = os::InvalidProcessId;
/* SD card helpers. */ /* SD card helpers. */
void GetPrivilegedProcessIdRange(os::ProcessId *out_min, os::ProcessId *out_max) { void GetPrivilegedProcessIdRange(os::ProcessId *out_min, os::ProcessId *out_max) {

6
libstratosphere/source/cfg/cfg_sd_card.cpp
View File

@ -29,9 +29,9 @@ namespace ams::cfg {
constexpr size_t NumRequiredServicesForSdCardAccess = util::size(RequiredServicesForSdCardAccess); constexpr size_t NumRequiredServicesForSdCardAccess = util::size(RequiredServicesForSdCardAccess);
/* SD card globals. */ /* SD card globals. */
os::Mutex g_sd_card_lock(false); constinit os::SdkMutex g_sd_card_lock;
bool g_sd_card_initialized = false; constinit bool g_sd_card_initialized = false;
FsFileSystem g_sd_card_filesystem = {}; constinit FsFileSystem g_sd_card_filesystem = {};
/* SD card helpers. */ /* SD card helpers. */
Result CheckSdCardServicesReady() { Result CheckSdCardServicesReady() {

4
libstratosphere/source/diag/diag_assertion_impl.cpp
View File

@ -44,8 +44,8 @@ namespace ams::diag {
inline void DebugLog(const char *format, ...) __attribute__((format(printf, 1, 2))); inline void DebugLog(const char *format, ...) __attribute__((format(printf, 1, 2)));
#ifdef AMS_ENABLE_DETAILED_ASSERTIONS #ifdef AMS_ENABLE_DETAILED_ASSERTIONS
os::Mutex g_debug_log_lock(true); constinit os::SdkRecursiveMutex g_debug_log_lock;
char g_debug_buffer[0x400]; constinit char g_debug_buffer[0x400];
void DebugLogImpl(const char *format, ::std::va_list vl) { void DebugLogImpl(const char *format, ::std::va_list vl) {
std::scoped_lock lk(g_debug_log_lock); std::scoped_lock lk(g_debug_log_lock);

2
libstratosphere/source/fs/fsa/fs_filesystem_accessor.cpp
View File

@ -60,7 +60,7 @@ namespace ams::fs::impl {
} }
FileSystemAccessor::FileSystemAccessor(const char *n, std::unique_ptr<fsa::IFileSystem> &&fs, std::unique_ptr<fsa::ICommonMountNameGenerator> &&generator) FileSystemAccessor::FileSystemAccessor(const char *n, std::unique_ptr<fsa::IFileSystem> &&fs, std::unique_ptr<fsa::ICommonMountNameGenerator> &&generator)
: impl(std::move(fs)), open_list_lock(false), mount_name_generator(std::move(generator)), : impl(std::move(fs)), open_list_lock(), mount_name_generator(std::move(generator)),
access_log_enabled(false), data_cache_attachable(false), path_cache_attachable(false), path_cache_attached(false), multi_commit_supported(false) access_log_enabled(false), data_cache_attachable(false), path_cache_attachable(false), path_cache_attached(false), multi_commit_supported(false)
{ {
R_ABORT_UNLESS(ValidateMountName(n)); R_ABORT_UNLESS(ValidateMountName(n));

2
libstratosphere/source/fs/fsa/fs_filesystem_accessor.hpp
View File

@ -35,7 +35,7 @@ namespace ams::fs::impl {
std::unique_ptr<fsa::IFileSystem> impl; std::unique_ptr<fsa::IFileSystem> impl;
FileList open_file_list; FileList open_file_list;
DirList open_dir_list; DirList open_dir_list;
os::Mutex open_list_lock; os::SdkMutex open_list_lock;
std::unique_ptr<fsa::ICommonMountNameGenerator> mount_name_generator; std::unique_ptr<fsa::ICommonMountNameGenerator> mount_name_generator;
bool access_log_enabled; bool access_log_enabled;
bool data_cache_attachable; bool data_cache_attachable;

4
libstratosphere/source/fs/fsa/fs_mount_table.hpp
View File

@ -26,9 +26,9 @@ namespace ams::fs::impl {
using FileSystemList = util::IntrusiveListBaseTraits<FileSystemAccessor>::ListType; using FileSystemList = util::IntrusiveListBaseTraits<FileSystemAccessor>::ListType;
private: private:
FileSystemList fs_list; FileSystemList fs_list;
os::Mutex mutex; os::SdkMutex mutex;
public: public:
constexpr MountTable() : fs_list(), mutex(false) { /* ... */ } constexpr MountTable() : fs_list(), mutex() { /* ... */ }
private: private:
bool CanAcceptMountName(const char *name); bool CanAcceptMountName(const char *name);
public: public:

2
libstratosphere/source/fssystem/fssystem_aes_xts_storage.cpp
View File

@ -17,7 +17,7 @@
namespace ams::fssystem { namespace ams::fssystem {
AesXtsStorage::AesXtsStorage(IStorage *base, const void *key1, const void *key2, size_t key_size, const void *iv, size_t iv_size, size_t block_size) : base_storage(base), block_size(block_size), mutex(false) { AesXtsStorage::AesXtsStorage(IStorage *base, const void *key1, const void *key2, size_t key_size, const void *iv, size_t iv_size, size_t block_size) : base_storage(base), block_size(block_size), mutex() {
AMS_ASSERT(base != nullptr); AMS_ASSERT(base != nullptr);
AMS_ASSERT(key1 != nullptr); AMS_ASSERT(key1 != nullptr);
AMS_ASSERT(key2 != nullptr); AMS_ASSERT(key2 != nullptr);

4
libstratosphere/source/fssystem/fssystem_directory_savedata_filesystem.cpp
View File

@ -74,13 +74,13 @@ namespace ams::fssystem {
} }
DirectorySaveDataFileSystem::DirectorySaveDataFileSystem(std::shared_ptr<fs::fsa::IFileSystem> fs) DirectorySaveDataFileSystem::DirectorySaveDataFileSystem(std::shared_ptr<fs::fsa::IFileSystem> fs)
: PathResolutionFileSystem(fs), accessor_mutex(false), open_writable_files(0) : PathResolutionFileSystem(fs), accessor_mutex(), open_writable_files(0)
{ {
/* ... */ /* ... */
} }
DirectorySaveDataFileSystem::DirectorySaveDataFileSystem(std::unique_ptr<fs::fsa::IFileSystem> fs) DirectorySaveDataFileSystem::DirectorySaveDataFileSystem(std::unique_ptr<fs::fsa::IFileSystem> fs)
: PathResolutionFileSystem(std::move(fs)), accessor_mutex(false), open_writable_files(0) : PathResolutionFileSystem(std::move(fs)), accessor_mutex(), open_writable_files(0)
{ {
/* ... */ /* ... */
} }

4
libstratosphere/source/fssystem/fssystem_hierarchical_sha256_storage.hpp
View File

@ -25,7 +25,7 @@ namespace ams::fssystem {
static constexpr s32 LayerCount = 3; static constexpr s32 LayerCount = 3;
static constexpr size_t HashSize = crypto::Sha256Generator::HashSize; static constexpr size_t HashSize = crypto::Sha256Generator::HashSize;
private: private:
os::Mutex mutex; os::SdkMutex mutex;
IStorage *base_storage; IStorage *base_storage;
s64 base_storage_size; s64 base_storage_size;
char *hash_buffer; char *hash_buffer;
@ -33,7 +33,7 @@ namespace ams::fssystem {
s32 hash_target_block_size; s32 hash_target_block_size;
s32 log_size_ratio; s32 log_size_ratio;
public: public:
HierarchicalSha256Storage() : mutex(false) { /* ... */ } HierarchicalSha256Storage() : mutex() { /* ... */ }
Result Initialize(IStorage **base_storages, s32 layer_count, size_t htbs, void *hash_buf, size_t hash_buf_size); Result Initialize(IStorage **base_storages, s32 layer_count, size_t htbs, void *hash_buf, size_t hash_buf_size);

8
libstratosphere/source/fssystem/fssystem_key_slot_cache.hpp
View File

@ -22,10 +22,10 @@ namespace ams::fssystem {
NON_COPYABLE(KeySlotCacheAccessor); NON_COPYABLE(KeySlotCacheAccessor);
NON_MOVEABLE(KeySlotCacheAccessor); NON_MOVEABLE(KeySlotCacheAccessor);
private: private:
util::unique_lock<os::Mutex> lk; util::unique_lock<os::SdkMutex> lk;
const s32 slot_index; const s32 slot_index;
public: public:
KeySlotCacheAccessor(s32 idx, util::unique_lock<os::Mutex> &&l) : lk(std::move(l)), slot_index(idx) { /* ... */ } KeySlotCacheAccessor(s32 idx, util::unique_lock<os::SdkMutex> &&l) : lk(std::move(l)), slot_index(idx) { /* ... */ }
s32 GetKeySlotIndex() const { return this->slot_index; } s32 GetKeySlotIndex() const { return this->slot_index; }
}; };
@ -64,11 +64,11 @@ namespace ams::fssystem {
private: private:
using KeySlotCacheEntryList = util::IntrusiveListBaseTraits<KeySlotCacheEntry>::ListType; using KeySlotCacheEntryList = util::IntrusiveListBaseTraits<KeySlotCacheEntry>::ListType;
private: private:
os::Mutex mutex; os::SdkMutex mutex;
KeySlotCacheEntryList high_priority_mru_list; KeySlotCacheEntryList high_priority_mru_list;
KeySlotCacheEntryList low_priority_mru_list; KeySlotCacheEntryList low_priority_mru_list;
public: public:
constexpr KeySlotCache() : mutex(false), high_priority_mru_list(), low_priority_mru_list() { /* ... */ } constexpr KeySlotCache() : mutex(), high_priority_mru_list(), low_priority_mru_list() { /* ... */ }
Result AllocateHighPriority(std::unique_ptr<KeySlotCacheAccessor> *out, const void *key, size_t key_size, s32 key2) { Result AllocateHighPriority(std::unique_ptr<KeySlotCacheAccessor> *out, const void *key, size_t key_size, s32 key2) {
return this->AllocateFromLru(out, this->high_priority_mru_list, key, key_size, key2); return this->AllocateFromLru(out, this->high_priority_mru_list, key, key_size, key2);

22
libstratosphere/source/fssystem/fssystem_pooled_buffer.cpp
View File

@ -21,13 +21,12 @@ namespace ams::fssystem {
class AdditionalDeviceAddressEntry { class AdditionalDeviceAddressEntry {
private: private:
/* TODO: SdkMutex */ os::SdkMutex mutex;
os::Mutex mutex;
bool is_registered; bool is_registered;
uintptr_t address; uintptr_t address;
size_t size; size_t size;
public: public:
constexpr AdditionalDeviceAddressEntry() : mutex(false), is_registered(), address(), size() { /* ... */ } constexpr AdditionalDeviceAddressEntry() : mutex(), is_registered(), address(), size() { /* ... */ }
void Register(uintptr_t addr, size_t sz) { void Register(uintptr_t addr, size_t sz) {
std::scoped_lock lk(this->mutex); std::scoped_lock lk(this->mutex);
@ -77,18 +76,17 @@ namespace ams::fssystem {
constexpr size_t HeapAllocatableSizeMax = HeapBlockSize * (static_cast<size_t>(1) << HeapOrderMax); constexpr size_t HeapAllocatableSizeMax = HeapBlockSize * (static_cast<size_t>(1) << HeapOrderMax);
constexpr size_t HeapAllocatableSizeMaxForLarge = HeapBlockSize * (static_cast<size_t>(1) << HeapOrderMaxForLarge); constexpr size_t HeapAllocatableSizeMaxForLarge = HeapBlockSize * (static_cast<size_t>(1) << HeapOrderMaxForLarge);
/* TODO: SdkMutex */ constinit os::SdkMutex g_heap_mutex;
os::Mutex g_heap_mutex(false); constinit FileSystemBuddyHeap g_heap;
FileSystemBuddyHeap g_heap;
std::atomic<size_t> g_retry_count; constinit std::atomic<size_t> g_retry_count;
std::atomic<size_t> g_reduce_allocation_count; constinit std::atomic<size_t> g_reduce_allocation_count;
void *g_heap_buffer; constinit void *g_heap_buffer;
size_t g_heap_size; constinit size_t g_heap_size;
size_t g_heap_free_size_peak; constinit size_t g_heap_free_size_peak;
AdditionalDeviceAddressEntry g_additional_device_address_entry; constinit AdditionalDeviceAddressEntry g_additional_device_address_entry;
} }

4
libstratosphere/source/fssystem/fssystem_read_only_block_cache_storage.hpp
View File

@ -25,12 +25,12 @@ namespace ams::fssystem {
private: private:
using BlockCache = LruListCache<s64, char *>; using BlockCache = LruListCache<s64, char *>;
private: private:
os::Mutex mutex; os::SdkMutex mutex;
BlockCache block_cache; BlockCache block_cache;
fs::IStorage * const base_storage; fs::IStorage * const base_storage;
s32 block_size; s32 block_size;
public: public:
ReadOnlyBlockCacheStorage(IStorage *bs, s32 bsz, char *buf, size_t buf_size, s32 cache_block_count) : mutex(false), base_storage(bs), block_size(bsz) { ReadOnlyBlockCacheStorage(IStorage *bs, s32 bsz, char *buf, size_t buf_size, s32 cache_block_count) : mutex(), base_storage(bs), block_size(bsz) {
/* Validate preconditions. */ /* Validate preconditions. */
AMS_ASSERT(buf_size >= static_cast<size_t>(this->block_size)); AMS_ASSERT(buf_size >= static_cast<size_t>(this->block_size));
AMS_ASSERT(util::IsPowerOfTwo(this->block_size)); AMS_ASSERT(util::IsPowerOfTwo(this->block_size));

2
libstratosphere/source/fssystem/save/fssystem_block_cache_buffered_storage.cpp
View File

@ -27,7 +27,7 @@ namespace ams::fssystem::save {
this->Finalize(); this->Finalize();
} }
Result BlockCacheBufferedStorage::Initialize(IBufferManager *bm, os::Mutex *mtx, IStorage *data, s64 data_size, size_t verif_block_size, s32 max_cache_entries, bool is_real_data, s8 buffer_level, bool is_keep_burst_mode, fs::StorageType storage_type) { Result BlockCacheBufferedStorage::Initialize(IBufferManager *bm, os::SdkRecursiveMutex *mtx, IStorage *data, s64 data_size, size_t verif_block_size, s32 max_cache_entries, bool is_real_data, s8 buffer_level, bool is_keep_burst_mode, fs::StorageType storage_type) {
/* Validate preconditions. */ /* Validate preconditions. */
AMS_ASSERT(data != nullptr); AMS_ASSERT(data != nullptr);
AMS_ASSERT(bm != nullptr); AMS_ASSERT(bm != nullptr);

2
libstratosphere/source/fssystem/save/fssystem_buffered_storage.cpp
View File

@ -582,7 +582,7 @@ namespace ams::fssystem::save {
} }
}; };
BufferedStorage::BufferedStorage() : base_storage(), buffer_manager(), block_size(), base_storage_size(), caches(), cache_count(), next_acquire_cache(), next_fetch_cache(), mutex(false), bulk_read_enabled() { BufferedStorage::BufferedStorage() : base_storage(), buffer_manager(), block_size(), base_storage_size(), caches(), cache_count(), next_acquire_cache(), next_fetch_cache(), mutex(), bulk_read_enabled() {
/* ... */ /* ... */
} }

2
libstratosphere/source/fssystem/save/fssystem_hierarchical_integrity_verification_storage.cpp
View File

@ -150,7 +150,7 @@ namespace ams::fssystem::save {
this->storage = fs::SubStorage(); this->storage = fs::SubStorage();
} }
Result HierarchicalIntegrityVerificationStorage::Initialize(const HierarchicalIntegrityVerificationInformation &info, HierarchicalStorageInformation storage, FileSystemBufferManagerSet *bufs, os::Mutex *mtx, fs::StorageType storage_type) { Result HierarchicalIntegrityVerificationStorage::Initialize(const HierarchicalIntegrityVerificationInformation &info, HierarchicalStorageInformation storage, FileSystemBufferManagerSet *bufs, os::SdkRecursiveMutex *mtx, fs::StorageType storage_type) {
/* Validate preconditions. */ /* Validate preconditions. */
AMS_ASSERT(bufs != nullptr); AMS_ASSERT(bufs != nullptr);
AMS_ASSERT(IntegrityMinLayerCount <= info.max_layers && info.max_layers <= IntegrityMaxLayerCount); AMS_ASSERT(IntegrityMinLayerCount <= info.max_layers && info.max_layers <= IntegrityMaxLayerCount);

4
libstratosphere/source/hid/hid_api.cpp
View File

@ -20,8 +20,8 @@ namespace ams::hid {
namespace { namespace {
/* Global lock. */ /* Global lock. */
os::Mutex g_hid_lock(false); constinit os::SdkMutex g_hid_lock;
bool g_initialized_hid = false; constinit bool g_initialized_hid = false;
/* Set of supported NpadIds (we want to read from any connected controllers). */ /* Set of supported NpadIds (we want to read from any connected controllers). */
constexpr const HidNpadIdType NpadIdTypes[] = { constexpr const HidNpadIdType NpadIdTypes[] = {

4
libstratosphere/source/lmem/impl/lmem_impl_common_heap.hpp
View File

@ -30,13 +30,13 @@ namespace ams::lmem::impl {
public: public:
explicit ScopedHeapLock(HeapHandle h) : handle(h) { explicit ScopedHeapLock(HeapHandle h) : handle(h) {
if (this->handle->option & CreateOption_ThreadSafe) { if (this->handle->option & CreateOption_ThreadSafe) {
os::LockMutex(std::addressof(this->handle->mutex)); os::LockSdkMutex(std::addressof(this->handle->mutex));
} }
} }
~ScopedHeapLock() { ~ScopedHeapLock() {
if (this->handle->option & CreateOption_ThreadSafe) { if (this->handle->option & CreateOption_ThreadSafe) {
os::UnlockMutex(std::addressof(this->handle->mutex)); os::UnlockSdkMutex(std::addressof(this->handle->mutex));
} }
} }
}; };

1
libstratosphere/source/lmem/impl/lmem_impl_exp_heap.cpp
View File

@ -427,6 +427,7 @@ namespace ams::lmem::impl {
const s32 abs_alignment = std::abs(alignment); const s32 abs_alignment = std::abs(alignment);
AMS_ASSERT((abs_alignment & (abs_alignment - 1)) == 0); AMS_ASSERT((abs_alignment & (abs_alignment - 1)) == 0);
AMS_ASSERT(MinimumAlignment <= static_cast<size_t>(abs_alignment)); AMS_ASSERT(MinimumAlignment <= static_cast<size_t>(abs_alignment));
AMS_UNUSED(abs_alignment);
/* Fix size to be correctly aligned. */ /* Fix size to be correctly aligned. */
if (size == 0) { if (size == 0) {

5
libstratosphere/source/lmem/lmem_exp_heap.cpp
View File

@ -21,15 +21,12 @@ namespace ams::lmem {
HeapHandle CreateExpHeap(void *address, size_t size, u32 option) { HeapHandle CreateExpHeap(void *address, size_t size, u32 option) {
HeapHandle handle = impl::CreateExpHeap(address, size, option); HeapHandle handle = impl::CreateExpHeap(address, size, option);
if (option & CreateOption_ThreadSafe) { if (option & CreateOption_ThreadSafe) {
os::InitializeMutex(std::addressof(handle->mutex), false, 0); os::InitializeSdkMutex(std::addressof(handle->mutex));
} }
return handle; return handle;
} }
void DestroyExpHeap(HeapHandle handle) { void DestroyExpHeap(HeapHandle handle) {
if (handle->option & CreateOption_ThreadSafe) {
os::FinalizeMutex(std::addressof(handle->mutex));
}
impl::DestroyExpHeap(handle); impl::DestroyExpHeap(handle);
} }

9
libstratosphere/source/lmem/lmem_unit_heap.cpp
View File

@ -21,7 +21,7 @@ namespace ams::lmem {
HeapHandle CreateUnitHeap(void *address, size_t size, size_t unit_size, u32 option) { HeapHandle CreateUnitHeap(void *address, size_t size, size_t unit_size, u32 option) {
HeapHandle handle = impl::CreateUnitHeap(address, size, unit_size, DefaultAlignment, static_cast<u16>(option), InfoPlacement_Head, nullptr); HeapHandle handle = impl::CreateUnitHeap(address, size, unit_size, DefaultAlignment, static_cast<u16>(option), InfoPlacement_Head, nullptr);
if (option & CreateOption_ThreadSafe) { if (option & CreateOption_ThreadSafe) {
os::InitializeMutex(std::addressof(handle->mutex), false, 0); os::InitializeSdkMutex(std::addressof(handle->mutex));
} }
return handle; return handle;
} }
@ -29,7 +29,7 @@ namespace ams::lmem {
HeapHandle CreateUnitHeap(void *address, size_t size, size_t unit_size, u32 option, s32 alignment, InfoPlacement info_placement) { HeapHandle CreateUnitHeap(void *address, size_t size, size_t unit_size, u32 option, s32 alignment, InfoPlacement info_placement) {
HeapHandle handle = impl::CreateUnitHeap(address, size, unit_size, alignment, static_cast<u16>(option), info_placement, nullptr); HeapHandle handle = impl::CreateUnitHeap(address, size, unit_size, alignment, static_cast<u16>(option), info_placement, nullptr);
if (option & CreateOption_ThreadSafe) { if (option & CreateOption_ThreadSafe) {
os::InitializeMutex(std::addressof(handle->mutex), false, 0); os::InitializeSdkMutex(std::addressof(handle->mutex));
} }
return handle; return handle;
} }
@ -37,15 +37,12 @@ namespace ams::lmem {
HeapHandle CreateUnitHeap(void *address, size_t size, size_t unit_size, u32 option, s32 alignment, HeapCommonHead *heap_head) { HeapHandle CreateUnitHeap(void *address, size_t size, size_t unit_size, u32 option, s32 alignment, HeapCommonHead *heap_head) {
HeapHandle handle = impl::CreateUnitHeap(address, size, unit_size, alignment, static_cast<u16>(option), InfoPlacement_Head, heap_head); HeapHandle handle = impl::CreateUnitHeap(address, size, unit_size, alignment, static_cast<u16>(option), InfoPlacement_Head, heap_head);
if (option & CreateOption_ThreadSafe) { if (option & CreateOption_ThreadSafe) {
os::InitializeMutex(std::addressof(handle->mutex), false, 0); os::InitializeSdkMutex(std::addressof(handle->mutex));
} }
return handle; return handle;
} }
void DestroyUnitHeap(HeapHandle handle) { void DestroyUnitHeap(HeapHandle handle) {
if (handle->option & CreateOption_ThreadSafe) {
os::FinalizeMutex(std::addressof(handle->mutex));
}
impl::DestroyUnitHeap(handle); impl::DestroyUnitHeap(handle);
} }

4
libstratosphere/source/mem/impl/heap/mem_impl_heap_tls_heap_central.hpp
View File

@ -201,14 +201,14 @@ namespace ams::mem::impl::heap {
s32 static_thread_quota; s32 static_thread_quota;
s32 dynamic_thread_quota; s32 dynamic_thread_quota;
bool use_virtual_memory; bool use_virtual_memory;
os::Mutex lock; os::SdkRecursiveMutex lock;
ListHeader<SpanPage> spanpage_list; ListHeader<SpanPage> spanpage_list;
ListHeader<SpanPage> full_spanpage_list; ListHeader<SpanPage> full_spanpage_list;
ListHeader<Span> freelists[FreeListCount]; ListHeader<Span> freelists[FreeListCount];
FreeListAvailableWord freelists_bitmap[NumFreeListBitmaps]; FreeListAvailableWord freelists_bitmap[NumFreeListBitmaps];
ListHeader<Span> smallmem_lists[TlsHeapStatic::NumClassInfo]; ListHeader<Span> smallmem_lists[TlsHeapStatic::NumClassInfo];
public: public:
TlsHeapCentral() : lock(true) { TlsHeapCentral() : lock() {
this->span_table.total_pages = 0; this->span_table.total_pages = 0;
} }

2
libstratosphere/source/ncm/ncm_install_task_base.cpp
View File

@ -635,7 +635,7 @@ namespace ams::ncm {
for (s32 i = 0; i < count; i++) { for (s32 i = 0; i < count; i++) {
R_UNLESS(!this->IsCancelRequested(), ncm::ResultCreatePlaceHolderCancelled()); R_UNLESS(!this->IsCancelRequested(), ncm::ResultCreatePlaceHolderCancelled());
static os::Mutex s_placeholder_mutex(false); static constinit os::SdkMutex s_placeholder_mutex;
std::scoped_lock lk(s_placeholder_mutex); std::scoped_lock lk(s_placeholder_mutex);
InstallContentMeta content_meta; InstallContentMeta content_meta;

4
libstratosphere/source/ncm/ncm_placeholder_accessor.hpp
View File

@ -32,7 +32,7 @@ namespace ams::ncm {
std::array<CacheEntry, MaxCacheEntries> caches; std::array<CacheEntry, MaxCacheEntries> caches;
PathString *root_path; PathString *root_path;
u64 cur_counter; u64 cur_counter;
os::Mutex cache_mutex; os::SdkMutex cache_mutex;
MakePlaceHolderPathFunction make_placeholder_path_func; MakePlaceHolderPathFunction make_placeholder_path_func;
bool delay_flush; bool delay_flush;
private: private:
@ -43,7 +43,7 @@ namespace ams::ncm {
CacheEntry *FindInCache(PlaceHolderId placeholder_id); CacheEntry *FindInCache(PlaceHolderId placeholder_id);
CacheEntry *GetFreeEntry();; CacheEntry *GetFreeEntry();;
public: public:
PlaceHolderAccessor() : cur_counter(0), cache_mutex(false), delay_flush(false) { PlaceHolderAccessor() : cur_counter(0), cache_mutex(), delay_flush(false) {
for (size_t i = 0; i < MaxCacheEntries; i++) { for (size_t i = 0; i < MaxCacheEntries; i++) {
caches[i].id = InvalidPlaceHolderId; caches[i].id = InvalidPlaceHolderId;
} }

6
libstratosphere/source/patcher/patcher_api.cpp
View File

@ -31,8 +31,8 @@ namespace ams::patcher {
constexpr size_t ModuleIpsPatchLength = 2 * sizeof(ro::ModuleId) + IpsFileExtensionLength; constexpr size_t ModuleIpsPatchLength = 2 * sizeof(ro::ModuleId) + IpsFileExtensionLength;
/* Global data. */ /* Global data. */
os::Mutex apply_patch_lock(false); constinit os::SdkMutex g_apply_patch_lock;
u8 g_patch_read_buffer[os::MemoryPageSize]; constinit u8 g_patch_read_buffer[os::MemoryPageSize];
/* Helpers. */ /* Helpers. */
inline u8 ConvertHexNybble(const char nybble) { inline u8 ConvertHexNybble(const char nybble) {
@ -213,7 +213,7 @@ namespace ams::patcher {
void LocateAndApplyIpsPatchesToModule(const char *mount_name, const char *patch_dir_name, size_t protected_size, size_t offset, const ro::ModuleId *module_id, u8 *mapped_module, size_t mapped_size) { void LocateAndApplyIpsPatchesToModule(const char *mount_name, const char *patch_dir_name, size_t protected_size, size_t offset, const ro::ModuleId *module_id, u8 *mapped_module, size_t mapped_size) {
/* Ensure only one thread tries to apply patches at a time. */ /* Ensure only one thread tries to apply patches at a time. */
std::scoped_lock lk(apply_patch_lock); std::scoped_lock lk(g_apply_patch_lock);
/* Inspect all patches from /atmosphere/<patch_dir>/<*>/<*>.ips */ /* Inspect all patches from /atmosphere/<patch_dir>/<*>/<*>.ips */
char path[fs::EntryNameLengthMax + 1]; char path[fs::EntryNameLengthMax + 1];

2
libstratosphere/source/sf/cmif/sf_cmif_domain_manager.cpp
View File

@ -106,7 +106,7 @@ namespace ams::sf::cmif {
return entry->object.Clone(); return entry->object.Clone();
} }
ServerDomainManager::EntryManager::EntryManager(DomainEntryStorage *entry_storage, size_t entry_count) : lock(false) { ServerDomainManager::EntryManager::EntryManager(DomainEntryStorage *entry_storage, size_t entry_count) : lock() {
this->entries = reinterpret_cast<Entry *>(entry_storage); this->entries = reinterpret_cast<Entry *>(entry_storage);
this->num_entries = entry_count; this->num_entries = entry_count;
for (size_t i = 0; i < this->num_entries; i++) { for (size_t i = 0; i < this->num_entries; i++) {

8
libstratosphere/source/sm/sm_utils.cpp
View File

@ -21,17 +21,17 @@ namespace ams::sm::impl {
namespace { namespace {
/* Globals. */ /* Globals. */
constinit os::Mutex g_mitm_ack_session_mutex(true); constinit os::SdkRecursiveMutex g_mitm_ack_session_mutex;
constinit os::Mutex g_per_thread_session_mutex(true); constinit os::SdkRecursiveMutex g_per_thread_session_mutex;
} }
/* Utilities. */ /* Utilities. */
os::Mutex &GetMitmAcknowledgementSessionMutex() { os::SdkRecursiveMutex &GetMitmAcknowledgementSessionMutex() {
return g_mitm_ack_session_mutex; return g_mitm_ack_session_mutex;
} }
os::Mutex &GetPerThreadSessionMutex() { os::SdkRecursiveMutex &GetPerThreadSessionMutex() {
return g_per_thread_session_mutex; return g_per_thread_session_mutex;
} }

4
libstratosphere/source/sm/sm_utils.hpp
View File

@ -21,8 +21,8 @@
namespace ams::sm::impl { namespace ams::sm::impl {
/* Utilities. */ /* Utilities. */
os::Mutex &GetMitmAcknowledgementSessionMutex(); os::SdkRecursiveMutex &GetMitmAcknowledgementSessionMutex();
os::Mutex &GetPerThreadSessionMutex(); os::SdkRecursiveMutex &GetPerThreadSessionMutex();
template<typename F> template<typename F>
Result DoWithMitmAcknowledgementSession(F f) { Result DoWithMitmAcknowledgementSession(F f) {

4
libvapours/source/sdmmc/impl/sdmmc_base_device_accessor.hpp
View File

@ -214,9 +214,9 @@ namespace ams::sdmmc::impl {
bool is_awake; bool is_awake;
public: public:
#if defined(AMS_SDMMC_THREAD_SAFE) #if defined(AMS_SDMMC_THREAD_SAFE)
mutable os::Mutex device_mutex; mutable os::SdkRecursiveMutex device_mutex;
public: public:
BaseDevice() : device_mutex(true) BaseDevice() : device_mutex()
#else #else
BaseDevice() BaseDevice()
#endif #endif