mirrors/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere.git synced 2025-06-04 16:53:48 -04:00
Code Issues Projects Releases Packages Wiki Activity

os: adopt multiwait naming over waitable

Browse source
This commit is contained in:
Michael Scire 2021-09-30 19:00:47 -07:00
parent d9b4009f82
commit 7444a68cd1
79 changed files with 869 additions and 869 deletions
Download patch file Download diff file Expand all files Collapse all files

4
libraries/libstratosphere/include/stratosphere/tipc/tipc_waitable_object.hpp → libraries/libstratosphere/include/stratosphere/tipc/tipc_object_holder.hpp
View file

@ -20,7 +20,7 @@
namespace ams::tipc {
class WaitableObject {
class ObjectHolder {
public:
enum ObjectType : u8 {
ObjectType_Invalid = 0,
@ -44,7 +44,7 @@ namespace ams::tipc {
m_object = object;
}
public:
constexpr inline WaitableObject() : m_handle(svc::InvalidHandle), m_type(ObjectType_Invalid), m_managed(false), m_object(nullptr) { /* ... */ }
constexpr inline ObjectHolder() : m_handle(svc::InvalidHandle), m_type(ObjectType_Invalid), m_managed(false), m_object(nullptr) { /* ... */ }
void InitializeAsPort(svc::Handle handle) {
/* NOTE: Nintendo sets ports as managed, but this will cause a nullptr-deref if one is ever closed. */

42
libraries/libstratosphere/include/stratosphere/tipc/tipc_object_manager.hpp
View file

@ -17,7 +17,7 @@
#include <vapours.hpp>
#include <stratosphere/tipc/tipc_common.hpp>
#include <stratosphere/tipc/tipc_service_object.hpp>
#include <stratosphere/tipc/tipc_waitable_object.hpp>
#include <stratosphere/tipc/tipc_object_holder.hpp>
namespace ams::tipc {
@ -28,14 +28,14 @@ namespace ams::tipc {
class ObjectManagerBase {
protected:
struct Entry {
util::TypedStorage<WaitableObject> object;
os::WaitableHolderType waitable_holder;
util::TypedStorage<ObjectHolder> object;
os::MultiWaitHolderType multi_wait_holder;
};
private:
os::SdkMutex m_mutex{};
Entry *m_entries_start{};
Entry *m_entries_end{};
os::WaitableManagerType *m_waitable_manager{};
os::MultiWaitType *m_multi_wait{};
private:
Entry *FindEntry(svc::Handle handle) {
for (Entry *cur = m_entries_start; cur != m_entries_end; ++cur) {
@ -46,9 +46,9 @@ namespace ams::tipc {
return nullptr;
}
Entry *FindEntry(os::WaitableHolderType *holder) {
Entry *FindEntry(os::MultiWaitHolderType *holder) {
for (Entry *cur = m_entries_start; cur != m_entries_end; ++cur) {
if (std::addressof(cur->waitable_holder) == holder) {
if (std::addressof(cur->multi_wait_holder) == holder) {
return cur;
}
}
@ -57,9 +57,9 @@ namespace ams::tipc {
public:
constexpr ObjectManagerBase() = default;
void InitializeImpl(os::WaitableManagerType *manager, Entry *entries, size_t max_objects) {
/* Set our waitable manager. */
m_waitable_manager = manager;
void InitializeImpl(os::MultiWaitType *multi_wait, Entry *entries, size_t max_objects) {
/* Set our multi wait. */
m_multi_wait = multi_wait;
/* Setup entry pointers. */
m_entries_start = entries;
@ -71,7 +71,7 @@ namespace ams::tipc {
}
}
void AddObject(WaitableObject &object) {
void AddObject(ObjectHolder &object) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
@ -83,8 +83,8 @@ namespace ams::tipc {
GetReference(entry->object) = object;
/* Setup the entry's holder. */
os::InitializeWaitableHolder(std::addressof(entry->waitable_holder), object.GetHandle());
os::LinkWaitableHolder(m_waitable_manager, std::addressof(entry->waitable_holder));
os::InitializeMultiWaitHolder(std::addressof(entry->multi_wait_holder), object.GetHandle());
os::LinkMultiWaitHolder(m_multi_wait, std::addressof(entry->multi_wait_holder));
}
void CloseObject(svc::Handle handle) {
@ -96,21 +96,21 @@ namespace ams::tipc {
AMS_ABORT_UNLESS(entry != nullptr);
/* Finalize the entry's holder. */
os::UnlinkWaitableHolder(std::addressof(entry->waitable_holder));
os::FinalizeWaitableHolder(std::addressof(entry->waitable_holder));
os::UnlinkMultiWaitHolder(std::addressof(entry->multi_wait_holder));
os::FinalizeMultiWaitHolder(std::addressof(entry->multi_wait_holder));
/* Destroy the object. */
GetReference(entry->object).Destroy();
}
Result ReplyAndReceive(os::WaitableHolderType **out_holder, WaitableObject *out_object, svc::Handle reply_target, os::WaitableManagerType *manager) {
Result ReplyAndReceive(os::MultiWaitHolderType **out_holder, ObjectHolder *out_object, svc::Handle reply_target, os::MultiWaitType *multi_wait) {
/* Declare signaled holder for processing ahead of time. */
os::WaitableHolderType *signaled_holder;
os::MultiWaitHolderType *signaled_holder;
/* Reply and receive until we get a newly signaled target. */
Result result = os::SdkReplyAndReceive(out_holder, reply_target, manager);
Result result = os::SdkReplyAndReceive(out_holder, reply_target, multi_wait);
for (signaled_holder = *out_holder; signaled_holder == nullptr; signaled_holder = *out_holder) {
result = os::SdkReplyAndReceive(out_holder, svc::InvalidHandle, manager);
result = os::SdkReplyAndReceive(out_holder, svc::InvalidHandle, multi_wait);
}
/* Find the entry matching the signaled holder. */
@ -140,7 +140,7 @@ namespace ams::tipc {
return ResultSuccess();
}
Result ProcessRequest(WaitableObject &object) {
Result ProcessRequest(ObjectHolder &object) {
/* Get the method id. */
const auto method_id = svc::ipc::MessageBuffer::MessageHeader(svc::ipc::MessageBuffer(svc::ipc::GetMessageBuffer())).GetTag();
@ -176,8 +176,8 @@ namespace ams::tipc {
public:
constexpr ObjectManager() = default;
void Initialize(os::WaitableManagerType *manager) {
this->InitializeImpl(manager, m_entries_storage, MaxObjects);
void Initialize(os::MultiWaitType *multi_wait) {
this->InitializeImpl(multi_wait, m_entries_storage, MaxObjects);
}
};

46
libraries/libstratosphere/include/stratosphere/tipc/tipc_server_manager.hpp
View file

@ -36,7 +36,7 @@ namespace ams::tipc {
class PortManagerInterface {
public:
virtual Result ProcessRequest(WaitableObject &object) = 0;
virtual Result ProcessRequest(ObjectHolder &object) = 0;
};
template<typename DeferralManagerType, size_t ThreadStackSize, typename... PortInfos>
@ -97,18 +97,18 @@ namespace ams::tipc {
s32 m_id;
std::atomic<s32> m_num_sessions;
s32 m_port_number;
os::WaitableManagerType m_waitable_manager;
os::MultiWaitType m_multi_wait;
DeferralManagerType m_deferral_manager;
os::MessageQueueType m_message_queue;
os::WaitableHolderType m_message_queue_holder;
os::MultiWaitHolderType m_message_queue_holder;
uintptr_t m_message_queue_storage[MaxSessions];
ObjectManagerBase *m_object_manager;
ServerManagerImpl *m_server_manager;
public:
PortManagerBase() : m_id(), m_num_sessions(), m_port_number(), m_waitable_manager(), m_deferral_manager(), m_message_queue(), m_message_queue_holder(), m_message_queue_storage(), m_object_manager(), m_server_manager() {
PortManagerBase() : m_id(), m_num_sessions(), m_port_number(), m_multi_wait(), m_deferral_manager(), m_message_queue(), m_message_queue_holder(), m_message_queue_storage(), m_object_manager(), m_server_manager() {
/* Setup our message queue. */
os::InitializeMessageQueue(std::addressof(m_message_queue), m_message_queue_storage, util::size(m_message_queue_storage));
os::InitializeWaitableHolder(std::addressof(m_message_queue_holder), std::addressof(m_message_queue), os::MessageQueueWaitType::ForNotEmpty);
os::InitializeMultiWaitHolder(std::addressof(m_message_queue_holder), std::addressof(m_message_queue), os::MessageQueueWaitType::ForNotEmpty);
}
constexpr s32 GetPortIndex() const {
@ -133,9 +133,9 @@ namespace ams::tipc {
/* Reset our session count. */
m_num_sessions = 0;
/* Initialize our waitable manager. */
os::InitializeWaitableManager(std::addressof(m_waitable_manager));
os::LinkWaitableHolder(std::addressof(m_waitable_manager), std::addressof(m_message_queue_holder));
/* Initialize our multi wait. */
os::InitializeMultiWait(std::addressof(m_multi_wait));
os::LinkMultiWaitHolder(std::addressof(m_multi_wait), std::addressof(m_message_queue_holder));
/* Initialize our object manager. */
m_object_manager = manager;
@ -145,8 +145,8 @@ namespace ams::tipc {
/* Set our port number. */
this->m_port_number = index;
/* Create a waitable object for the port. */
tipc::WaitableObject object;
/* Create an object holder for the port. */
tipc::ObjectHolder object;
/* Setup the object. */
object.InitializeAsPort(port_handle);
@ -155,7 +155,7 @@ namespace ams::tipc {
m_object_manager->AddObject(object);
}
virtual Result ProcessRequest(WaitableObject &object) override {
virtual Result ProcessRequest(ObjectHolder &object) override {
/* Process the request, this must succeed because we succeeded when deferring earlier. */
R_ABORT_UNLESS(m_object_manager->ProcessRequest(object));
@ -168,13 +168,13 @@ namespace ams::tipc {
return m_object_manager->Reply(object.GetHandle());
}
Result ReplyAndReceive(os::WaitableHolderType **out_holder, WaitableObject *out_object, svc::Handle reply_target) {
return m_object_manager->ReplyAndReceive(out_holder, out_object, reply_target, std::addressof(m_waitable_manager));
Result ReplyAndReceive(os::MultiWaitHolderType **out_holder, ObjectHolder *out_object, svc::Handle reply_target) {
return m_object_manager->ReplyAndReceive(out_holder, out_object, reply_target, std::addressof(m_multi_wait));
}
void AddSession(svc::Handle session_handle, tipc::ServiceObjectBase *service_object) {
/* Create a waitable object for the session. */
tipc::WaitableObject object;
/* Create an object holder for the session. */
tipc::ObjectHolder object;
/* Setup the object. */
object.InitializeAsSession(session_handle, true, service_object);
@ -219,7 +219,7 @@ namespace ams::tipc {
}
}
void CloseSession(WaitableObject &object) {
void CloseSession(ObjectHolder &object) {
/* Get the object's handle. */
const auto handle = object.GetHandle();
@ -233,7 +233,7 @@ namespace ams::tipc {
--m_num_sessions;
}
void CloseSessionIfNecessary(WaitableObject &object, bool necessary) {
void CloseSessionIfNecessary(ObjectHolder &object, bool necessary) {
if (necessary) {
/* Get the object's handle. */
const auto handle = object.GetHandle();
@ -261,7 +261,7 @@ namespace ams::tipc {
}
}
void ProcessRegisterRetry(WaitableObject &object) {
void ProcessRegisterRetry(ObjectHolder &object) {
if constexpr (IsDeferralSupported) {
/* Acquire exclusive server manager access. */
std::scoped_lock lk(m_server_manager->GetMutex());
@ -342,7 +342,7 @@ namespace ams::tipc {
this->InitializeBase(id, sm, std::addressof(m_object_manager_impl));
/* Initialize our object manager. */
m_object_manager_impl.Initialize(std::addressof(this->m_waitable_manager));
m_object_manager_impl.Initialize(std::addressof(this->m_multi_wait));
}
};
@ -517,8 +517,8 @@ namespace ams::tipc {
svc::Handle reply_target = svc::InvalidHandle;
while (true) {
/* Reply to our pending request, and receive a new one. */
os::WaitableHolderType *signaled_holder = nullptr;
tipc::WaitableObject signaled_object{};
os::MultiWaitHolderType *signaled_holder = nullptr;
tipc::ObjectHolder signaled_object{};
R_TRY_CATCH(port_manager.ReplyAndReceive(std::addressof(signaled_holder), std::addressof(signaled_object), reply_target)) {
R_CATCH(os::ResultSessionClosedForReceive, os::ResultReceiveListBroken) {
/* Close the object and continue. */
@ -533,7 +533,7 @@ namespace ams::tipc {
if (signaled_holder == nullptr) {
/* A session was signaled, accessible via signaled_object. */
switch (signaled_object.GetType()) {
case WaitableObject::ObjectType_Port:
case ObjectHolder::ObjectType_Port:
{
/* Try to accept a new session */
svc::Handle session_handle;
@ -545,7 +545,7 @@ namespace ams::tipc {
reply_target = svc::InvalidHandle;
}
break;
case WaitableObject::ObjectType_Session:
case ObjectHolder::ObjectType_Session:
{
/* Process the request */
const Result process_result = port_manager.GetObjectManager()->ProcessRequest(signaled_object);