OmniNX/Atmosphere
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 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

6
libraries/libstratosphere/include/stratosphere/ddsf/ddsf_event_handler_manager.hpp
View File

@@ -31,10 +31,10 @@ namespace ams::ddsf {
bool is_initialized;
bool is_looping;
os::SdkConditionVariable is_looping_cv;
os::WaitableManagerType waitable_manager;
os::MultiWaitType multi_wait;
os::ThreadType *loop_thread;
os::Event loop_control_event;
os::WaitableHolderType loop_control_event_holder;
os::MultiWaitHolderType loop_control_event_holder;
LoopControlCommandParameters *loop_control_command_params;
os::LightEvent loop_control_command_done_event;
os::SdkMutex loop_control_lock;
@@ -43,7 +43,7 @@ namespace ams::ddsf {
void ProcessControlCommandImpl(LoopControlCommandParameters *params);
public:
EventHandlerManager()
: is_initialized(false), is_looping(false), is_looping_cv(), waitable_manager(),
: is_initialized(false), is_looping(false), is_looping_cv(), multi_wait(),
loop_thread(), loop_control_event(os::EventClearMode_AutoClear), loop_control_event_holder(),
loop_control_command_params(), loop_control_command_done_event(os::EventClearMode_AutoClear),
loop_control_lock()

20
libraries/libstratosphere/include/stratosphere/ddsf/ddsf_i_event_handler.hpp
View File

@@ -26,27 +26,27 @@ namespace ams::ddsf {
NON_MOVEABLE(IEventHandler);
friend class EventHandlerManager;
private:
os::WaitableHolderType holder;
os::MultiWaitHolderType holder;
uintptr_t user_data;
bool is_initialized;
bool is_registered;
private:
void Link(os::WaitableManagerType *manager) {
void Link(os::MultiWaitType *multi_wait) {
AMS_ASSERT(this->IsInitialized());
AMS_ASSERT(!this->IsRegistered());
AMS_ASSERT(manager != nullptr);
os::LinkWaitableHolder(manager, std::addressof(this->holder));
AMS_ASSERT(multi_wait != nullptr);
os::LinkMultiWaitHolder(multi_wait, std::addressof(this->holder));
}
void Unlink() {
AMS_ASSERT(this->IsInitialized());
AMS_ASSERT(this->IsRegistered());
os::UnlinkWaitableHolder(std::addressof(this->holder));
os::UnlinkMultiWaitHolder(std::addressof(this->holder));
}
static IEventHandler &ToEventHandler(os::WaitableHolderType *holder) {
static IEventHandler &ToEventHandler(os::MultiWaitHolderType *holder) {
AMS_ASSERT(holder != nullptr);
auto &event_handler = *reinterpret_cast<IEventHandler *>(os::GetWaitableHolderUserData(holder));
auto &event_handler = *reinterpret_cast<IEventHandler *>(os::GetMultiWaitHolderUserData(holder));
AMS_ASSERT(event_handler.IsInitialized());
return event_handler;
}
@@ -72,8 +72,8 @@ namespace ams::ddsf {
void Initialize(T *object) {
AMS_ASSERT(object != nullptr);
AMS_ASSERT(!this->IsInitialized());
os::InitializeWaitableHolder(std::addressof(this->holder), object);
os::SetWaitableHolderUserData(std::addressof(this->holder), reinterpret_cast<uintptr_t>(this));
os::InitializeMultiWaitHolder(std::addressof(this->holder), object);
os::SetMultiWaitHolderUserData(std::addressof(this->holder), reinterpret_cast<uintptr_t>(this));
this->is_initialized = true;
this->is_registered = false;
}
@@ -81,7 +81,7 @@ namespace ams::ddsf {
void Finalize() {
AMS_ASSERT(this->IsInitialized());
AMS_ASSERT(!this->IsRegistered());
os::FinalizeWaitableHolder(std::addressof(this->holder));
os::FinalizeMultiWaitHolder(std::addressof(this->holder));
this->is_initialized = false;
this->is_registered = false;
}

2
libraries/libstratosphere/include/stratosphere/os.hpp
View File

@@ -50,4 +50,4 @@
#include <stratosphere/os/os_light_semaphore.hpp>
#include <stratosphere/os/os_barrier.hpp>
#include <stratosphere/os/os_io_region.hpp>
#include <stratosphere/os/os_waitable.hpp>
#include <stratosphere/os/os_multiple_wait.hpp>

4
libraries/libstratosphere/include/stratosphere/os/os_event_api.hpp
View File

@@ -21,7 +21,7 @@
namespace ams::os {
struct EventType;
struct WaitableHolderType;
struct MultiWaitHolderType;
void InitializeEvent(EventType *event, bool signaled, EventClearMode clear_mode);
void FinalizeEvent(EventType *event);
@@ -32,6 +32,6 @@ namespace ams::os {
bool TimedWaitEvent(EventType *event, TimeSpan timeout);
void ClearEvent(EventType *event);
void InitializeWaitableHolder(WaitableHolderType *waitable_holder, EventType *event);
void InitializeMultiWaitHolder(MultiWaitHolderType *multi_wait_holder, EventType *event);
}

4
libraries/libstratosphere/include/stratosphere/os/os_event_types.hpp
View File

@@ -23,7 +23,7 @@ namespace ams::os {
namespace impl {
class WaitableObjectList;
class MultiWaitObjectList;
}
@@ -33,7 +33,7 @@ namespace ams::os {
State_Initialized = 1,
};
util::TypedStorage<impl::WaitableObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitable_object_list_storage;
util::TypedStorage<impl::MultiWaitObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> multi_wait_object_list_storage;
bool signaled;
bool initially_signaled;
u8 clear_mode;

4
libraries/libstratosphere/include/stratosphere/os/os_interrupt_event_api.hpp
View File

@@ -21,7 +21,7 @@
namespace ams::os {
struct InterruptEventType;
struct WaitableHolderType;
struct MultiWaitHolderType;
void InitializeInterruptEvent(InterruptEventType *event, InterruptName name, EventClearMode clear_mode);
void FinalizeInterruptEvent(InterruptEventType *event);
@@ -31,6 +31,6 @@ namespace ams::os {
bool TimedWaitInterruptEvent(InterruptEventType *event, TimeSpan timeout);
void ClearInterruptEvent(InterruptEventType *event);
void InitializeWaitableHolder(WaitableHolderType *waitable_holder, InterruptEventType *event);
void InitializeMultiWaitHolder(MultiWaitHolderType *multi_wait_holder, InterruptEventType *event);
}

4
libraries/libstratosphere/include/stratosphere/os/os_interrupt_event_types.hpp
View File

@@ -23,7 +23,7 @@ namespace ams::os {
namespace impl {
class WaitableObjectList;
class MultiWaitObjectList;
class InterruptEventImpl;
}
@@ -34,7 +34,7 @@ namespace ams::os {
State_Initialized = 1,
};
util::TypedStorage<impl::WaitableObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitable_object_list_storage;
util::TypedStorage<impl::MultiWaitObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> multi_wait_object_list_storage;
u8 clear_mode;
u8 state;

4
libraries/libstratosphere/include/stratosphere/os/os_message_queue_api.hpp
View File

@@ -21,7 +21,7 @@
namespace ams::os {
struct MessageQueueType;
struct WaitableHolderType;
struct MultiWaitHolderType;
void InitializeMessageQueue(MessageQueueType *mq, uintptr_t *buffer, size_t count);
void FinalizeMessageQueue(MessageQueueType *mq);
@@ -46,6 +46,6 @@ namespace ams::os {
bool TryPeekMessageQueue(uintptr_t *out, const MessageQueueType *mq);
bool TimedPeekMessageQueue(uintptr_t *out, const MessageQueueType *mq, TimeSpan timeout);
void InitializeWaitableHolder(WaitableHolderType *waitable_holder, MessageQueueType *event, MessageQueueWaitType wait_type);
void InitializeMultiWaitHolder(MultiWaitHolderType *multi_wait_holder, MessageQueueType *event, MessageQueueWaitType wait_type);
}

6
libraries/libstratosphere/include/stratosphere/os/os_message_queue_types.hpp
View File

@@ -23,7 +23,7 @@ namespace ams::os {
namespace impl {
class WaitableObjectList;
class MultiWaitObjectList;
}
@@ -33,8 +33,8 @@ namespace ams::os {
State_Initialized = 1,
};
util::TypedStorage<impl::WaitableObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitlist_not_full;
util::TypedStorage<impl::WaitableObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitlist_not_empty;
util::TypedStorage<impl::MultiWaitObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitlist_not_full;
util::TypedStorage<impl::MultiWaitObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitlist_not_empty;
uintptr_t *buffer;
s32 capacity;
s32 count;

6
libraries/libstratosphere/include/stratosphere/os/os_waitable.hpp → libraries/libstratosphere/include/stratosphere/os/os_multiple_wait.hpp
View File

@@ -14,6 +14,6 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <stratosphere/os/os_waitable_types.hpp>
#include <stratosphere/os/os_waitable_api.hpp>
#include <stratosphere/os/os_waitable_utils.hpp>
#include <stratosphere/os/os_multiple_wait_types.hpp>
#include <stratosphere/os/os_multiple_wait_api.hpp>
#include <stratosphere/os/os_multiple_wait_utils.hpp>

45
libraries/libstratosphere/include/stratosphere/os/os_multiple_wait_api.hpp Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright (c) 2018-2020 Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <vapours.hpp>
#include <stratosphere/os/os_message_queue_common.hpp>
namespace ams::os {
struct MultiWaitHolderType;
struct MultiWaitType;
void InitializeMultiWait(MultiWaitType *multi_wait);
void FinalizeMultiWait(MultiWaitType *multi_wait);
MultiWaitHolderType *WaitAny(MultiWaitType *multi_wait);
MultiWaitHolderType *TryWaitAny(MultiWaitType *multi_wait);
MultiWaitHolderType *TimedWaitAny(MultiWaitType *multi_wait, TimeSpan timeout);
void FinalizeMultiWaitHolder(MultiWaitHolderType *holder);
void LinkMultiWaitHolder(MultiWaitType *multi_wait, MultiWaitHolderType *holder);
void UnlinkMultiWaitHolder(MultiWaitHolderType *holder);
void UnlinkAllMultiWaitHolder(MultiWaitType *multi_wait);
void MoveAllMultiWaitHolder(MultiWaitType *dst, MultiWaitType *src);
void SetMultiWaitHolderUserData(MultiWaitHolderType *holder, uintptr_t user_data);
uintptr_t GetMultiWaitHolderUserData(const MultiWaitHolderType *holder);
void InitializeMultiWaitHolder(MultiWaitHolderType *holder, Handle handle);
}

16
libraries/libstratosphere/include/stratosphere/os/os_waitable_types.hpp → libraries/libstratosphere/include/stratosphere/os/os_multiple_wait_types.hpp
View File

@@ -21,12 +21,12 @@ namespace ams::os {
namespace impl {
class WaitableManagerImpl;
struct WaitableHolderImpl;
class MultiWaitImpl;
struct MultiWaitHolderImpl;
}
struct WaitableManagerType {
struct MultiWaitType {
enum State {
State_NotInitialized,
State_Initialized,
@@ -34,14 +34,14 @@ namespace ams::os {
u8 state;
bool is_waiting;
util::TypedStorage<impl::WaitableManagerImpl, sizeof(util::IntrusiveListNode) + sizeof(impl::InternalCriticalSection) + 2 * sizeof(void *) + sizeof(Handle), alignof(void *)> impl_storage;
util::TypedStorage<impl::MultiWaitImpl, sizeof(util::IntrusiveListNode) + sizeof(impl::InternalCriticalSection) + 2 * sizeof(void *) + sizeof(Handle), alignof(void *)> impl_storage;
};
static_assert(std::is_trivial<WaitableManagerType>::value);
static_assert(std::is_trivial<MultiWaitType>::value);
struct WaitableHolderType {
util::TypedStorage<impl::WaitableHolderImpl, 2 * sizeof(util::IntrusiveListNode) + 3 * sizeof(void *), alignof(void *)> impl_storage;
struct MultiWaitHolderType {
util::TypedStorage<impl::MultiWaitHolderImpl, 2 * sizeof(util::IntrusiveListNode) + 3 * sizeof(void *), alignof(void *)> impl_storage;
uintptr_t user_data;
};
static_assert(std::is_trivial<WaitableHolderType>::value);
static_assert(std::is_trivial<MultiWaitHolderType>::value);
}

124
libraries/libstratosphere/include/stratosphere/os/os_multiple_wait_utils.hpp Normal file
View File

@@ -0,0 +1,124 @@
/*
* Copyright (c) 2018-2020 Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <vapours.hpp>
#include <stratosphere/os/os_message_queue_common.hpp>
#include <stratosphere/os/os_multiple_wait_api.hpp>
#include <stratosphere/os/os_multiple_wait_types.hpp>
namespace ams::os {
namespace impl {
class AutoMultiWaitHolder {
private:
MultiWaitHolderType m_holder;
public:
template<typename T>
ALWAYS_INLINE explicit AutoMultiWaitHolder(MultiWaitType *multi_wait, T &&arg) {
InitializeMultiWaitHolder(std::addressof(m_holder), std::forward<T>(arg));
LinkMultiWaitHolder(multi_wait, std::addressof(m_holder));
}
ALWAYS_INLINE ~AutoMultiWaitHolder() {
UnlinkMultiWaitHolder(std::addressof(m_holder));
FinalizeMultiWaitHolder(std::addressof(m_holder));
}
ALWAYS_INLINE std::pair<MultiWaitHolderType *, int> ConvertResult(const std::pair<MultiWaitHolderType *, int> result, int index) {
if (result.first == std::addressof(m_holder)) {
return std::make_pair(static_cast<MultiWaitHolderType *>(nullptr), index);
} else {
return result;
}
}
};
template<typename F>
inline std::pair<MultiWaitHolderType *, int> WaitAnyImpl(F &&func, MultiWaitType *multi_wait, int) {
return std::pair<MultiWaitHolderType *, int>(func(multi_wait), -1);
}
template<typename F, typename T, typename... Args>
inline std::pair<MultiWaitHolderType *, int> WaitAnyImpl(F &&func, MultiWaitType *multi_wait, int index, T &&x, Args &&... args) {
AutoMultiWaitHolder holder(multi_wait, std::forward<T>(x));
return holder.ConvertResult(WaitAnyImpl(std::forward<F>(func), multi_wait, index + 1, std::forward<Args>(args)...), index);
}
template<typename F, typename... Args>
inline std::pair<MultiWaitHolderType *, int> WaitAnyImpl(F &&func, MultiWaitType *multi_wait, Args &&... args) {
return WaitAnyImpl(std::forward<F>(func), multi_wait, 0, std::forward<Args>(args)...);
}
class TempMultiWait {
private:
MultiWaitType m_multi_wait;
public:
ALWAYS_INLINE TempMultiWait() {
os::InitializeMultiWait(std::addressof(m_multi_wait));
}
ALWAYS_INLINE ~TempMultiWait() {
os::FinalizeMultiWait(std::addressof(m_multi_wait));
}
MultiWaitType *Get() {
return std::addressof(m_multi_wait);
}
};
template<typename F, typename... Args>
inline std::pair<MultiWaitHolderType *, int> WaitAnyImpl(F &&func, Args &&... args) {
TempMultiWait temp_multi_wait;
return WaitAnyImpl(std::forward<F>(func), temp_multi_wait.Get(), 0, std::forward<Args>(args)...);
}
using WaitAnyFunction = MultiWaitHolderType * (*)(MultiWaitType *);
class NotBoolButInt {
private:
int m_value;
public:
constexpr ALWAYS_INLINE NotBoolButInt(int v) : m_value(v) { /* ... */ }
constexpr ALWAYS_INLINE operator int() const { return m_value; }
explicit operator bool() const = delete;
};
}
template<typename... Args> requires (sizeof...(Args) > 0)
inline std::pair<MultiWaitHolderType *, int> WaitAny(MultiWaitType *multi_wait, Args &&... args) {
return impl::WaitAnyImpl(static_cast<impl::WaitAnyFunction>(&::ams::os::WaitAny), multi_wait, std::forward<Args>(args)...);
}
template<typename... Args> requires (sizeof...(Args) > 0)
inline int WaitAny(Args &&... args) {
return impl::WaitAnyImpl(static_cast<impl::WaitAnyFunction>(&::ams::os::WaitAny), std::forward<Args>(args)...).second;
}
template<typename... Args> requires (sizeof...(Args) > 0)
inline std::pair<MultiWaitHolderType *, int> TryWaitAny(MultiWaitType *multi_wait, Args &&... args) {
return impl::WaitAnyImpl(static_cast<impl::WaitAnyFunction>(&::ams::os::TryWaitAny), multi_wait, std::forward<Args>(args)...);
}
template<typename... Args> requires (sizeof...(Args) > 0)
inline impl::NotBoolButInt TryWaitAny(Args &&... args) {
return impl::WaitAnyImpl(static_cast<impl::WaitAnyFunction>(&::ams::os::TryWaitAny), std::forward<Args>(args)...).second;
}
}

6
libraries/libstratosphere/include/stratosphere/os/os_sdk_reply_and_receive.hpp
View File

@@ -18,9 +18,9 @@
namespace ams::os {
struct WaitableHolderType;
struct WaitableManagerType;
struct MultiWaitHolderType;
struct MultiWaitType;
Result SdkReplyAndReceive(os::WaitableHolderType **out, Handle reply_target, WaitableManagerType *manager);
Result SdkReplyAndReceive(os::MultiWaitHolderType **out, Handle reply_target, MultiWaitType *multi_wait);
}

4
libraries/libstratosphere/include/stratosphere/os/os_semaphore_api.hpp
View File

@@ -20,7 +20,7 @@
namespace ams::os {
struct SemaphoreType;
struct WaitableHolderType;
struct MultiWaitHolderType;
void InitializeSemaphore(SemaphoreType *sema, s32 count, s32 max_count);
void FinalizeSemaphore(SemaphoreType *sema);
@@ -34,6 +34,6 @@ namespace ams::os {
s32 GetCurrentSemaphoreCount(const SemaphoreType *sema);
void InitializeWaitableHolder(WaitableHolderType *waitable_holder, SemaphoreType *sema);
void InitializeMultiWaitHolder(MultiWaitHolderType *multi_wait_holder, SemaphoreType *sema);
}

4
libraries/libstratosphere/include/stratosphere/os/os_semaphore_types.hpp
View File

@@ -23,7 +23,7 @@ namespace ams::os {
namespace impl {
class WaitableObjectList;
class MultiWaitObjectList;
}
@@ -33,7 +33,7 @@ namespace ams::os {
State_Initialized = 1,
};
util::TypedStorage<impl::WaitableObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitlist;
util::TypedStorage<impl::MultiWaitObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitlist;
u8 state;
s32 count;
s32 max_count;

4
libraries/libstratosphere/include/stratosphere/os/os_system_event_api.hpp
View File

@@ -21,7 +21,7 @@
namespace ams::os {
struct SystemEventType;
struct WaitableHolderType;
struct MultiWaitHolderType;
Result CreateSystemEvent(SystemEventType *event, EventClearMode clear_mode, bool inter_process);
void DestroySystemEvent(SystemEventType *event);
@@ -42,6 +42,6 @@ namespace ams::os {
bool TimedWaitSystemEvent(SystemEventType *event, TimeSpan timeout);
void ClearSystemEvent(SystemEventType *event);
void InitializeWaitableHolder(WaitableHolderType *waitable_holder, SystemEventType *event);
void InitializeMultiWaitHolder(MultiWaitHolderType *multi_wait_holder, SystemEventType *event);
}

2
libraries/libstratosphere/include/stratosphere/os/os_system_event_types.hpp
View File

@@ -28,7 +28,7 @@ namespace ams::os {
State_Initialized = 1,
};
util::TypedStorage<impl::WaitableObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitable_object_list_storage;
util::TypedStorage<impl::MultiWaitObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> multi_wait_object_list_storage;
bool auto_clear;
u8 state;

4
libraries/libstratosphere/include/stratosphere/os/os_thread_api.hpp
View File

@@ -21,7 +21,7 @@
namespace ams::os {
struct ThreadType;
struct WaitableHolderType;
struct MultiWaitHolderType;
Result CreateThread(ThreadType *thread, ThreadFunction function, void *argument, void *stack, size_t stack_size, s32 priority, s32 ideal_core);
Result CreateThread(ThreadType *thread, ThreadFunction function, void *argument, void *stack, size_t stack_size, s32 priority);
@@ -62,6 +62,6 @@ namespace ams::os {
ThreadId GetThreadId(const ThreadType *thread);
void InitializeWaitableHolder(WaitableHolderType *holder, ThreadType *thread);
void InitializeMultiWaitHolder(MultiWaitHolderType *holder, ThreadType *thread);
}

4
libraries/libstratosphere/include/stratosphere/os/os_thread_types.hpp
View File

@@ -26,7 +26,7 @@ namespace ams::os {
namespace impl {
class WaitableObjectList;
class MultiWaitObjectList;
}
@@ -47,7 +47,7 @@ namespace ams::os {
};
util::TypedStorage<util::IntrusiveListNode> all_threads_node;
util::TypedStorage<impl::WaitableObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitlist;
util::TypedStorage<impl::MultiWaitObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitlist;
uintptr_t reserved[4];
u8 state;
u8 suspend_count;

4
libraries/libstratosphere/include/stratosphere/os/os_timer_event_api.hpp
View File

@@ -21,7 +21,7 @@
namespace ams::os {
struct TimerEventType;
struct WaitableHolderType;
struct MultiWaitHolderType;
void InitializeTimerEvent(TimerEventType *event, EventClearMode clear_mode);
void FinalizeTimerEvent(TimerEventType *event);
@@ -36,6 +36,6 @@ namespace ams::os {
void SignalTimerEvent(TimerEventType *event);
void ClearTimerEvent(TimerEventType *event);
void InitializeWaitableHolder(WaitableHolderType *waitable_holder, TimerEventType *event);
void InitializeMultiWaitHolder(MultiWaitHolderType *multi_wait_holder, TimerEventType *event);
}

4
libraries/libstratosphere/include/stratosphere/os/os_timer_event_types.hpp
View File

@@ -24,7 +24,7 @@ namespace ams::os {
namespace impl {
class WaitableObjectList;
class MultiWaitObjectList;
}
@@ -42,7 +42,7 @@ namespace ams::os {
TimerState_Periodic = 2,
};
util::TypedStorage<impl::WaitableObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> waitable_object_list_storage;
util::TypedStorage<impl::MultiWaitObjectList, sizeof(util::IntrusiveListNode), alignof(util::IntrusiveListNode)> multi_wait_object_list_storage;
u8 state;
u8 clear_mode;

45
libraries/libstratosphere/include/stratosphere/os/os_waitable_api.hpp
View File

@@ -1,45 +0,0 @@
/*
* Copyright (c) 2018-2020 Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <vapours.hpp>
#include <stratosphere/os/os_message_queue_common.hpp>
namespace ams::os {
struct WaitableHolderType;
struct WaitableManagerType;
void InitializeWaitableManager(WaitableManagerType *manager);
void FinalizeWaitableManager(WaitableManagerType *manager);
WaitableHolderType *WaitAny(WaitableManagerType *manager);
WaitableHolderType *TryWaitAny(WaitableManagerType *manager);
WaitableHolderType *TimedWaitAny(WaitableManagerType *manager, TimeSpan timeout);
void FinalizeWaitableHolder(WaitableHolderType *holder);
void LinkWaitableHolder(WaitableManagerType *manager, WaitableHolderType *holder);
void UnlinkWaitableHolder(WaitableHolderType *holder);
void UnlinkAllWaitableHolder(WaitableManagerType *manager);
void MoveAllWaitableHolder(WaitableManagerType *dst, WaitableManagerType *src);
void SetWaitableHolderUserData(WaitableHolderType *holder, uintptr_t user_data);
uintptr_t GetWaitableHolderUserData(const WaitableHolderType *holder);
void InitializeWaitableHolder(WaitableHolderType *holder, Handle handle);
}

124
libraries/libstratosphere/include/stratosphere/os/os_waitable_utils.hpp
View File

@@ -1,124 +0,0 @@
/*
* Copyright (c) 2018-2020 Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <vapours.hpp>
#include <stratosphere/os/os_message_queue_common.hpp>
#include <stratosphere/os/os_waitable_api.hpp>
#include <stratosphere/os/os_waitable_types.hpp>
namespace ams::os {
namespace impl {
class AutoWaitableHolder {
private:
WaitableHolderType m_holder;
public:
template<typename T>
ALWAYS_INLINE explicit AutoWaitableHolder(WaitableManagerType *manager, T &&arg) {
InitializeWaitableHolder(std::addressof(m_holder), std::forward<T>(arg));
LinkWaitableHolder(manager, std::addressof(m_holder));
}
ALWAYS_INLINE ~AutoWaitableHolder() {
UnlinkWaitableHolder(std::addressof(m_holder));
FinalizeWaitableHolder(std::addressof(m_holder));
}
ALWAYS_INLINE std::pair<WaitableHolderType *, int> ConvertResult(const std::pair<WaitableHolderType *, int> result, int index) {
if (result.first == std::addressof(m_holder)) {
return std::make_pair(static_cast<WaitableHolderType *>(nullptr), index);
} else {
return result;
}
}
};
template<typename F>
inline std::pair<WaitableHolderType *, int> WaitAnyImpl(F &&func, WaitableManagerType *manager, int) {
return std::pair<WaitableHolderType *, int>(func(manager), -1);
}
template<typename F, typename T, typename... Args>
inline std::pair<WaitableHolderType *, int> WaitAnyImpl(F &&func, WaitableManagerType *manager, int index, T &&x, Args &&... args) {
AutoWaitableHolder holder(manager, std::forward<T>(x));
return holder.ConvertResult(WaitAnyImpl(std::forward<F>(func), manager, index + 1, std::forward<Args>(args)...), index);
}
template<typename F, typename... Args>
inline std::pair<WaitableHolderType *, int> WaitAnyImpl(F &&func, WaitableManagerType *manager, Args &&... args) {
return WaitAnyImpl(std::forward<F>(func), manager, 0, std::forward<Args>(args)...);
}
class TempWaitableManager {
private:
WaitableManagerType m_manager;
public:
ALWAYS_INLINE TempWaitableManager() {
os::InitializeWaitableManager(std::addressof(m_manager));
}
ALWAYS_INLINE ~TempWaitableManager() {
os::FinalizeWaitableManager(std::addressof(m_manager));
}
WaitableManagerType *Get() {
return std::addressof(m_manager);
}
};
template<typename F, typename... Args>
inline std::pair<WaitableHolderType *, int> WaitAnyImpl(F &&func, Args &&... args) {
TempWaitableManager temp_manager;
return WaitAnyImpl(std::forward<F>(func), temp_manager.Get(), 0, std::forward<Args>(args)...);
}
using WaitAnyFunction = WaitableHolderType * (*)(WaitableManagerType *);
class NotBoolButInt {
private:
int m_value;
public:
constexpr ALWAYS_INLINE NotBoolButInt(int v) : m_value(v) { /* ... */ }
constexpr ALWAYS_INLINE operator int() const { return m_value; }
explicit operator bool() const = delete;
};
}
template<typename... Args> requires (sizeof...(Args) > 0)
inline std::pair<WaitableHolderType *, int> WaitAny(WaitableManagerType *manager, Args &&... args) {
return impl::WaitAnyImpl(static_cast<impl::WaitAnyFunction>(&::ams::os::WaitAny), manager, std::forward<Args>(args)...);
}
template<typename... Args> requires (sizeof...(Args) > 0)
inline int WaitAny(Args &&... args) {
return impl::WaitAnyImpl(static_cast<impl::WaitAnyFunction>(&::ams::os::WaitAny), std::forward<Args>(args)...).second;
}
template<typename... Args> requires (sizeof...(Args) > 0)
inline std::pair<WaitableHolderType *, int> TryWaitAny(WaitableManagerType *manager, Args &&... args) {
return impl::WaitAnyImpl(static_cast<impl::WaitAnyFunction>(&::ams::os::TryWaitAny), manager, std::forward<Args>(args)...);
}
template<typename... Args> requires (sizeof...(Args) > 0)
inline impl::NotBoolButInt TryWaitAny(Args &&... args) {
return impl::WaitAnyImpl(static_cast<impl::WaitAnyFunction>(&::ams::os::TryWaitAny), std::forward<Args>(args)...).second;
}
}

4
libraries/libstratosphere/include/stratosphere/sf/hipc/sf_hipc_api.hpp
View File

@@ -28,8 +28,8 @@ namespace ams::sf::hipc {
NeedsRetry,
};
void AttachWaitableHolderForAccept(os::WaitableHolderType *holder, Handle port);
void AttachWaitableHolderForReply(os::WaitableHolderType *holder, Handle request);
void AttachMultiWaitHolderForAccept(os::MultiWaitHolderType *holder, Handle port);
void AttachMultiWaitHolderForReply(os::MultiWaitHolderType *holder, Handle request);
Result Receive(ReceiveResult *out_recv_result, Handle session_handle, const cmif::PointerAndSize &message_buffer);
Result Receive(bool *out_closed, Handle session_handle, const cmif::PointerAndSize &message_buffer);

63
libraries/libstratosphere/include/stratosphere/sf/hipc/sf_hipc_server_manager.hpp
View File

@@ -47,7 +47,7 @@ namespace ams::sf::hipc {
using ServerDomainSessionManager::DomainEntryStorage;
using ServerDomainSessionManager::DomainStorage;
protected:
class Server : public os::WaitableHolderType {
class Server : public os::MultiWaitHolderType {
friend class ServerManagerBase;
template<size_t, typename, size_t>
friend class ServerManager;
@@ -73,42 +73,42 @@ namespace ams::sf::hipc {
}
};
private:
/* Management of waitables. */
os::WaitableManagerType waitable_manager;
/* Multiple wait management. */
os::MultiWaitType multi_wait;
os::Event request_stop_event;
os::WaitableHolderType request_stop_event_holder;
os::MultiWaitHolderType request_stop_event_holder;
os::Event notify_event;
os::WaitableHolderType notify_event_holder;
os::MultiWaitHolderType notify_event_holder;
os::SdkMutex waitable_selection_mutex;
os::SdkMutex selection_mutex;
os::SdkMutex waitlist_mutex;
os::WaitableManagerType waitlist;
os::SdkMutex deferred_list_mutex;
os::MultiWaitType deferred_list;
private:
virtual void RegisterSessionToWaitList(ServerSession *session) override final;
void RegisterToWaitList(os::WaitableHolderType *holder);
void ProcessWaitList();
virtual void RegisterServerSessionToWait(ServerSession *session) override final;
void LinkToDeferredList(os::MultiWaitHolderType *holder);
void LinkDeferred();
bool WaitAndProcessImpl();
Result ProcessForServer(os::WaitableHolderType *holder);
Result ProcessForMitmServer(os::WaitableHolderType *holder);
Result ProcessForSession(os::WaitableHolderType *holder);
Result ProcessForServer(os::MultiWaitHolderType *holder);
Result ProcessForMitmServer(os::MultiWaitHolderType *holder);
Result ProcessForSession(os::MultiWaitHolderType *holder);
void RegisterServerImpl(Server *server, Handle port_handle, bool is_mitm_server) {
server->port_handle = port_handle;
hipc::AttachWaitableHolderForAccept(server, port_handle);
hipc::AttachMultiWaitHolderForAccept(server, port_handle);
server->is_mitm_server = is_mitm_server;
if (is_mitm_server) {
/* Mitm server. */
os::SetWaitableHolderUserData(server, static_cast<uintptr_t>(UserDataTag::MitmServer));
os::SetMultiWaitHolderUserData(server, static_cast<uintptr_t>(UserDataTag::MitmServer));
} else {
/* Non-mitm server. */
os::SetWaitableHolderUserData(server, static_cast<uintptr_t>(UserDataTag::Server));
os::SetMultiWaitHolderUserData(server, static_cast<uintptr_t>(UserDataTag::Server));
}
os::LinkWaitableHolder(std::addressof(this->waitable_manager), server);
os::LinkMultiWaitHolder(std::addressof(this->multi_wait), server);
}
void RegisterServerImpl(int index, cmif::ServiceObjectHolder &&static_holder, Handle port_handle, bool is_mitm_server) {
@@ -192,15 +192,16 @@ namespace ams::sf::hipc {
ServerManagerBase(DomainEntryStorage *entry_storage, size_t entry_count) :
ServerDomainSessionManager(entry_storage, entry_count),
request_stop_event(os::EventClearMode_ManualClear), notify_event(os::EventClearMode_ManualClear),
waitable_selection_mutex(), waitlist_mutex()
selection_mutex(), deferred_list_mutex()
{
/* Link waitables. */
os::InitializeWaitableManager(std::addressof(this->waitable_manager));
os::InitializeWaitableHolder(std::addressof(this->request_stop_event_holder), this->request_stop_event.GetBase());
os::LinkWaitableHolder(std::addressof(this->waitable_manager), std::addressof(this->request_stop_event_holder));
os::InitializeWaitableHolder(std::addressof(this->notify_event_holder), this->notify_event.GetBase());
os::LinkWaitableHolder(std::addressof(this->waitable_manager), std::addressof(this->notify_event_holder));
os::InitializeWaitableManager(std::addressof(this->waitlist));
/* Link multi-wait holders. */
os::InitializeMultiWait(std::addressof(this->multi_wait));
os::InitializeMultiWaitHolder(std::addressof(this->request_stop_event_holder), this->request_stop_event.GetBase());
os::LinkMultiWaitHolder(std::addressof(this->multi_wait), std::addressof(this->request_stop_event_holder));
os::InitializeMultiWaitHolder(std::addressof(this->notify_event_holder), this->notify_event.GetBase());
os::LinkMultiWaitHolder(std::addressof(this->multi_wait), std::addressof(this->notify_event_holder));
os::InitializeMultiWait(std::addressof(this->deferred_list));
}
template<typename Interface>
@@ -227,13 +228,13 @@ namespace ams::sf::hipc {
}
/* Processing. */
os::WaitableHolderType *WaitSignaled();
os::MultiWaitHolderType *WaitSignaled();
void ResumeProcessing();
void RequestStopProcessing();
void AddUserWaitableHolder(os::WaitableHolderType *waitable);
void AddUserMultiWaitHolder(os::MultiWaitHolderType *holder);
Result Process(os::WaitableHolderType *waitable);
Result Process(os::MultiWaitHolderType *holder);
void WaitAndProcess();
void LoopProcess();
};
@@ -324,8 +325,8 @@ namespace ams::sf::hipc {
const size_t index = this->GetServerIndex(server);
AMS_ABORT_UNLESS(this->server_allocated[index]);
{
os::UnlinkWaitableHolder(server);
os::FinalizeWaitableHolder(server);
os::UnlinkMultiWaitHolder(server);
os::FinalizeMultiWaitHolder(server);
if (server->service_managed) {
if (server->is_mitm_server) {
R_ABORT_UNLESS(sm::mitm::UninstallMitm(server->service_name));

8
libraries/libstratosphere/include/stratosphere/sf/hipc/sf_hipc_server_session_manager.hpp
View File

@@ -38,7 +38,7 @@ namespace ams::sf::hipc {
}
class ServerSession : public os::WaitableHolderType {
class ServerSession : public os::MultiWaitHolderType {
friend class ServerSessionManager;
friend class ServerManagerBase;
friend class impl::HipcManagerImpl;
@@ -54,7 +54,7 @@ namespace ams::sf::hipc {
bool has_received;
public:
ServerSession(Handle h, cmif::ServiceObjectHolder &&obj) : srv_obj_holder(std::move(obj)), session_handle(h) {
hipc::AttachWaitableHolderForReply(this, h);
hipc::AttachMultiWaitHolderForReply(this, h);
this->is_closed = false;
this->has_received = false;
this->forward_service = nullptr;
@@ -62,7 +62,7 @@ namespace ams::sf::hipc {
}
ServerSession(Handle h, cmif::ServiceObjectHolder &&obj, std::shared_ptr<::Service> &&fsrv) : srv_obj_holder(std::move(obj)), session_handle(h) {
hipc::AttachWaitableHolderForReply(this, h);
hipc::AttachMultiWaitHolderForReply(this, h);
this->is_closed = false;
this->has_received = false;
this->forward_service = std::move(fsrv);
@@ -105,7 +105,7 @@ namespace ams::sf::hipc {
void DestroySession(ServerSession *session);
Result ProcessRequestImpl(ServerSession *session, const cmif::PointerAndSize &in_message, const cmif::PointerAndSize &out_message);
virtual void RegisterSessionToWaitList(ServerSession *session) = 0;
virtual void RegisterServerSessionToWait(ServerSession *session) = 0;
protected:
Result DispatchRequest(cmif::ServiceObjectHolder &&obj, ServerSession *session, const cmif::PointerAndSize &in_message, const cmif::PointerAndSize &out_message);
virtual Result DispatchManagerRequest(ServerSession *session, const cmif::PointerAndSize &in_message, const cmif::PointerAndSize &out_message);

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);