Atmosphere/libraries/libstratosphere/source/os/impl/os_multiple_wait_impl.cpp

204 lines
7.8 KiB
C++
Raw Normal View History

/*
* Copyright (c) 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/>.
*/
#include <stratosphere.hpp>
#include "os_multiple_wait_impl.hpp"
#include "os_multiple_wait_object_list.hpp"
2020-04-08 09:21:35 +00:00
#include "os_tick_manager.hpp"
2020-04-08 09:21:35 +00:00
namespace ams::os::impl {
Result MultiWaitImpl::WaitAnyImpl(MultiWaitHolderBase **out, bool infinite, TimeSpan timeout, bool reply, NativeHandle reply_target) {
/* Prepare for processing. */
2021-10-10 07:14:06 +00:00
m_signaled_holder = nullptr;
m_target_impl.SetCurrentThreadHandleForCancelWait();
MultiWaitHolderBase *holder = this->LinkHoldersToObjectList();
/* Check if we've been signaled. */
{
2021-10-10 07:14:06 +00:00
std::scoped_lock lk(m_cs_wait);
if (m_signaled_holder != nullptr) {
holder = m_signaled_holder;
}
}
/* Process object array. */
2021-01-13 02:18:39 +00:00
Result wait_result = ResultSuccess();
if (holder != nullptr) {
if (reply && reply_target != os::InvalidNativeHandle) {
2021-01-13 02:18:39 +00:00
s32 index;
2021-10-10 07:14:06 +00:00
wait_result = m_target_impl.TimedReplyAndReceive(std::addressof(index), nullptr, 0, 0, reply_target, TimeSpan::FromNanoSeconds(0));
2021-01-13 02:18:39 +00:00
if (R_FAILED(wait_result)) {
holder = nullptr;
}
}
} else {
wait_result = this->WaitAnyHandleImpl(std::addressof(holder), infinite, timeout, reply, reply_target);
}
/* Unlink holders from the current object list. */
this->UnlinkHoldersFromObjectList();
2021-10-10 07:14:06 +00:00
m_target_impl.ClearCurrentThreadHandleForCancelWait();
2020-04-08 09:21:35 +00:00
2021-01-13 02:18:39 +00:00
/* Set output holder. */
*out = holder;
return wait_result;
}
Result MultiWaitImpl::WaitAnyHandleImpl(MultiWaitHolderBase **out, bool infinite, TimeSpan timeout, bool reply, NativeHandle reply_target) {
NativeHandle object_handles[MaximumHandleCount];
MultiWaitHolderBase *objects[MaximumHandleCount];
2020-04-08 09:21:35 +00:00
const s32 count = this->BuildHandleArray(object_handles, objects, MaximumHandleCount);
const TimeSpan end_time = infinite ? TimeSpan::FromNanoSeconds(std::numeric_limits<s64>::max()) : GetCurrentTick().ToTimeSpan() + timeout;
while (true) {
2021-10-10 07:14:06 +00:00
m_current_time = GetCurrentTick().ToTimeSpan();
2020-04-08 09:21:35 +00:00
TimeSpan min_timeout = 0;
MultiWaitHolderBase *min_timeout_object = this->RecalculateNextTimeout(std::addressof(min_timeout), end_time);
2021-01-13 02:18:39 +00:00
s32 index = WaitInvalid;
Result wait_result = ResultSuccess();
if (reply) {
if (infinite && min_timeout_object == nullptr) {
2021-10-10 07:14:06 +00:00
wait_result = m_target_impl.ReplyAndReceive(std::addressof(index), object_handles, MaximumHandleCount, count, reply_target);
2021-01-13 02:18:39 +00:00
} else {
2021-10-10 07:14:06 +00:00
wait_result = m_target_impl.TimedReplyAndReceive(std::addressof(index), object_handles, MaximumHandleCount, count, reply_target, min_timeout);
2021-01-13 02:18:39 +00:00
}
} else if (infinite && min_timeout_object == nullptr) {
2021-10-10 07:14:06 +00:00
wait_result = m_target_impl.WaitAny(std::addressof(index), object_handles, MaximumHandleCount, count);
} else {
2020-04-08 09:21:35 +00:00
if (count == 0 && min_timeout == 0) {
index = WaitTimedOut;
} else {
2021-10-10 07:14:06 +00:00
wait_result = m_target_impl.TimedWaitAny(std::addressof(index), object_handles, MaximumHandleCount, count, min_timeout);
2020-04-08 09:21:35 +00:00
AMS_ABORT_UNLESS(index != WaitInvalid);
}
}
2021-01-13 02:18:39 +00:00
if (index == WaitInvalid) {
*out = nullptr;
return wait_result;
}
switch (index) {
case WaitTimedOut:
if (min_timeout_object) {
2021-10-10 07:14:06 +00:00
m_current_time = GetCurrentTick().ToTimeSpan();
if (min_timeout_object->IsSignaled() == TriBool::True) {
2021-10-10 07:14:06 +00:00
std::scoped_lock lk(m_cs_wait);
m_signaled_holder = min_timeout_object;
*out = min_timeout_object;
2021-01-13 02:18:39 +00:00
return wait_result;
}
2021-01-13 02:18:39 +00:00
} else {
*out = nullptr;
return wait_result;
}
2021-01-13 02:18:39 +00:00
break;
case WaitCancelled:
2021-01-13 02:18:39 +00:00
{
2021-10-10 07:14:06 +00:00
std::scoped_lock lk(m_cs_wait);
if (m_signaled_holder) {
*out = m_signaled_holder;
2021-01-13 02:18:39 +00:00
return wait_result;
}
}
2021-01-13 02:18:39 +00:00
break;
default: /* 0 - 0x3F, valid. */
{
2021-01-13 02:18:39 +00:00
AMS_ASSERT(0 <= index && index < static_cast<s32>(MaximumHandleCount));
2021-10-10 07:14:06 +00:00
std::scoped_lock lk(m_cs_wait);
m_signaled_holder = objects[index];
*out = objects[index];
2021-01-13 02:18:39 +00:00
return wait_result;
}
break;
}
2021-01-13 02:18:39 +00:00
reply_target = os::InvalidNativeHandle;
}
}
s32 MultiWaitImpl::BuildHandleArray(NativeHandle out_handles[], MultiWaitHolderBase *out_objects[], s32 num) {
2020-04-08 09:21:35 +00:00
s32 count = 0;
2021-10-10 07:14:06 +00:00
for (MultiWaitHolderBase &holder_base : m_multi_wait_list) {
if (auto handle = holder_base.GetHandle(); handle != os::InvalidNativeHandle) {
AMS_ABORT_UNLESS(count < num);
out_handles[count] = handle;
out_objects[count] = std::addressof(holder_base);
count++;
}
}
return count;
}
MultiWaitHolderBase *MultiWaitImpl::LinkHoldersToObjectList() {
MultiWaitHolderBase *signaled_holder = nullptr;
2021-10-10 07:14:06 +00:00
for (MultiWaitHolderBase &holder_base : m_multi_wait_list) {
TriBool is_signaled = holder_base.LinkToObjectList();
if (signaled_holder == nullptr && is_signaled == TriBool::True) {
signaled_holder = std::addressof(holder_base);
}
}
return signaled_holder;
}
void MultiWaitImpl::UnlinkHoldersFromObjectList() {
2021-10-10 07:14:06 +00:00
for (MultiWaitHolderBase &holder_base : m_multi_wait_list) {
holder_base.UnlinkFromObjectList();
}
}
MultiWaitHolderBase *MultiWaitImpl::RecalculateNextTimeout(TimeSpan *out_min_timeout, TimeSpan end_time) {
MultiWaitHolderBase *min_timeout_holder = nullptr;
2020-04-08 09:21:35 +00:00
TimeSpan min_time = end_time;
2021-10-10 07:14:06 +00:00
for (MultiWaitHolderBase &holder_base : m_multi_wait_list) {
2020-04-08 09:21:35 +00:00
if (const TimeSpan cur_time = holder_base.GetAbsoluteWakeupTime(); cur_time < min_time) {
min_timeout_holder = std::addressof(holder_base);
min_time = cur_time;
}
}
2021-10-10 07:14:06 +00:00
if (min_time < m_current_time) {
*out_min_timeout = 0;
} else {
2021-10-10 07:14:06 +00:00
*out_min_timeout = min_time - m_current_time;
}
return min_timeout_holder;
}
void MultiWaitImpl::SignalAndWakeupThread(MultiWaitHolderBase *holder_base) {
2021-10-10 07:14:06 +00:00
std::scoped_lock lk(m_cs_wait);
2021-10-10 07:14:06 +00:00
if (m_signaled_holder == nullptr) {
m_signaled_holder = holder_base;
m_target_impl.CancelWait();
}
}
}