2014-05-09 22:11:18 -04:00
|
|
|
// Copyright 2014 Citra Emulator Project / PPSSPP Project
|
2014-12-17 00:38:14 -05:00
|
|
|
// Licensed under GPLv2 or any later version
|
2014-11-19 03:49:13 -05:00
|
|
|
// Refer to the license.txt file included.
|
2014-05-09 22:11:18 -04:00
|
|
|
|
2014-06-05 22:35:36 -04:00
|
|
|
#include <algorithm>
|
2018-02-14 00:33:15 -05:00
|
|
|
#include <cinttypes>
|
2018-10-30 00:03:25 -04:00
|
|
|
#include <optional>
|
2014-08-17 23:03:22 -04:00
|
|
|
#include <vector>
|
2018-07-31 08:06:09 -04:00
|
|
|
|
2015-05-06 03:06:12 -04:00
|
|
|
#include "common/assert.h"
|
|
|
|
#include "common/common_types.h"
|
2020-02-24 21:04:12 -05:00
|
|
|
#include "common/fiber.h"
|
2015-05-06 03:06:12 -04:00
|
|
|
#include "common/logging/log.h"
|
2014-05-15 18:27:08 -04:00
|
|
|
#include "common/thread_queue_list.h"
|
2014-05-13 22:00:11 -04:00
|
|
|
#include "core/core.h"
|
2020-02-24 21:04:12 -05:00
|
|
|
#include "core/cpu_manager.h"
|
2020-02-11 18:56:24 -05:00
|
|
|
#include "core/hardware_properties.h"
|
2017-05-21 03:11:36 -04:00
|
|
|
#include "core/hle/kernel/errors.h"
|
2017-05-29 19:45:42 -04:00
|
|
|
#include "core/hle/kernel/handle_table.h"
|
2020-12-30 04:14:02 -05:00
|
|
|
#include "core/hle/kernel/k_condition_variable.h"
|
2020-12-02 21:08:35 -05:00
|
|
|
#include "core/hle/kernel/k_scheduler.h"
|
2020-12-04 00:56:02 -05:00
|
|
|
#include "core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h"
|
2020-12-31 02:01:08 -05:00
|
|
|
#include "core/hle/kernel/k_thread.h"
|
2018-08-28 12:30:33 -04:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
2020-12-30 04:14:02 -05:00
|
|
|
#include "core/hle/kernel/memory/memory_layout.h"
|
2018-08-01 22:40:00 -04:00
|
|
|
#include "core/hle/kernel/object.h"
|
2016-09-17 20:38:01 -04:00
|
|
|
#include "core/hle/kernel/process.h"
|
2020-02-24 21:04:12 -05:00
|
|
|
#include "core/hle/kernel/time_manager.h"
|
2014-10-22 23:20:01 -04:00
|
|
|
#include "core/hle/result.h"
|
2015-05-12 21:38:29 -04:00
|
|
|
#include "core/memory.h"
|
2014-05-09 22:11:18 -04:00
|
|
|
|
2020-07-15 13:13:31 -04:00
|
|
|
#ifdef ARCHITECTURE_x86_64
|
|
|
|
#include "core/arm/dynarmic/arm_dynarmic_32.h"
|
|
|
|
#include "core/arm/dynarmic/arm_dynarmic_64.h"
|
|
|
|
#endif
|
|
|
|
|
2014-05-20 19:37:46 -04:00
|
|
|
namespace Kernel {
|
2014-05-13 22:00:11 -04:00
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
bool KThread::IsSignaled() const {
|
2020-12-22 01:36:53 -05:00
|
|
|
return signaled;
|
2020-02-11 16:36:39 -05:00
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
KThread::KThread(KernelCore& kernel) : KSynchronizationObject{kernel} {}
|
|
|
|
KThread::~KThread() = default;
|
2015-01-31 16:22:40 -05:00
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
void KThread::Stop() {
|
2020-03-03 12:02:50 -05:00
|
|
|
{
|
2020-12-04 01:26:42 -05:00
|
|
|
KScopedSchedulerLock lock(kernel);
|
2020-12-28 16:16:43 -05:00
|
|
|
SetState(ThreadState::Terminated);
|
2020-12-22 01:36:53 -05:00
|
|
|
signaled = true;
|
|
|
|
NotifyAvailable();
|
2020-03-03 12:37:11 -05:00
|
|
|
kernel.GlobalHandleTable().Close(global_handle);
|
2020-03-03 12:02:50 -05:00
|
|
|
|
2020-03-11 20:44:53 -04:00
|
|
|
if (owner_process) {
|
|
|
|
owner_process->UnregisterThread(this);
|
2020-03-03 12:02:50 -05:00
|
|
|
|
2020-03-11 20:44:53 -04:00
|
|
|
// Mark the TLS slot in the thread's page as free.
|
|
|
|
owner_process->FreeTLSRegion(tls_address);
|
|
|
|
}
|
2020-03-07 13:16:25 -05:00
|
|
|
has_exited = true;
|
2020-03-03 12:02:50 -05:00
|
|
|
}
|
2020-02-14 08:30:53 -05:00
|
|
|
global_handle = 0;
|
2014-05-13 22:00:11 -04:00
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
void KThread::Wakeup() {
|
2020-12-04 01:26:42 -05:00
|
|
|
KScopedSchedulerLock lock(kernel);
|
2020-12-28 16:16:43 -05:00
|
|
|
SetState(ThreadState::Runnable);
|
2020-02-24 21:04:12 -05:00
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
ResultCode KThread::Start() {
|
2020-12-04 01:26:42 -05:00
|
|
|
KScopedSchedulerLock lock(kernel);
|
2020-12-28 16:16:43 -05:00
|
|
|
SetState(ThreadState::Runnable);
|
2020-02-25 11:40:33 -05:00
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
void KThread::CancelWait() {
|
2020-12-04 01:26:42 -05:00
|
|
|
KScopedSchedulerLock lock(kernel);
|
2020-12-28 16:16:43 -05:00
|
|
|
if (GetState() != ThreadState::Waiting || !is_cancellable) {
|
2019-11-16 10:05:39 -05:00
|
|
|
is_sync_cancelled = true;
|
|
|
|
return;
|
|
|
|
}
|
2020-03-07 11:44:35 -05:00
|
|
|
// TODO(Blinkhawk): Implement cancel of server session
|
2019-11-16 10:05:39 -05:00
|
|
|
is_sync_cancelled = false;
|
2020-02-25 15:38:33 -05:00
|
|
|
SetSynchronizationResults(nullptr, ERR_SYNCHRONIZATION_CANCELED);
|
2020-12-28 16:16:43 -05:00
|
|
|
SetState(ThreadState::Runnable);
|
2019-04-17 07:08:12 -04:00
|
|
|
}
|
|
|
|
|
2020-03-01 23:46:10 -05:00
|
|
|
static void ResetThreadContext32(Core::ARM_Interface::ThreadContext32& context, u32 stack_top,
|
|
|
|
u32 entry_point, u32 arg) {
|
|
|
|
context = {};
|
|
|
|
context.cpu_registers[0] = arg;
|
|
|
|
context.cpu_registers[15] = entry_point;
|
|
|
|
context.cpu_registers[13] = stack_top;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ResetThreadContext64(Core::ARM_Interface::ThreadContext64& context, VAddr stack_top,
|
|
|
|
VAddr entry_point, u64 arg) {
|
2018-10-12 10:57:28 -04:00
|
|
|
context = {};
|
2016-09-02 08:53:42 -04:00
|
|
|
context.cpu_registers[0] = arg;
|
|
|
|
context.pc = entry_point;
|
|
|
|
context.sp = stack_top;
|
2018-12-17 18:04:02 -05:00
|
|
|
// TODO(merry): Perform a hardware test to determine the below value.
|
2020-04-19 03:37:20 -04:00
|
|
|
context.fpcr = 0;
|
2016-09-02 08:53:42 -04:00
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
std::shared_ptr<Common::Fiber>& KThread::GetHostContext() {
|
2020-02-24 21:04:12 -05:00
|
|
|
return host_context;
|
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
ResultVal<std::shared_ptr<KThread>> KThread::Create(Core::System& system, ThreadType type_flags,
|
|
|
|
std::string name, VAddr entry_point,
|
|
|
|
u32 priority, u64 arg, s32 processor_id,
|
|
|
|
VAddr stack_top, Process* owner_process) {
|
2020-07-16 13:28:10 -04:00
|
|
|
std::function<void(void*)> init_func = Core::CpuManager::GetGuestThreadStartFunc();
|
2020-02-24 21:04:12 -05:00
|
|
|
void* init_func_parameter = system.GetCpuManager().GetStartFuncParamater();
|
|
|
|
return Create(system, type_flags, name, entry_point, priority, arg, processor_id, stack_top,
|
|
|
|
owner_process, std::move(init_func), init_func_parameter);
|
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
ResultVal<std::shared_ptr<KThread>> KThread::Create(Core::System& system, ThreadType type_flags,
|
|
|
|
std::string name, VAddr entry_point,
|
|
|
|
u32 priority, u64 arg, s32 processor_id,
|
|
|
|
VAddr stack_top, Process* owner_process,
|
|
|
|
std::function<void(void*)>&& thread_start_func,
|
|
|
|
void* thread_start_parameter) {
|
2020-02-24 21:04:12 -05:00
|
|
|
auto& kernel = system.Kernel();
|
2017-05-21 03:11:36 -04:00
|
|
|
// Check if priority is in ranged. Lowest priority -> highest priority id.
|
2020-02-25 11:40:33 -05:00
|
|
|
if (priority > THREADPRIO_LOWEST && ((type_flags & THREADTYPE_IDLE) == 0)) {
|
2018-07-02 12:13:26 -04:00
|
|
|
LOG_ERROR(Kernel_SVC, "Invalid thread priority: {}", priority);
|
2018-09-12 04:25:53 -04:00
|
|
|
return ERR_INVALID_THREAD_PRIORITY;
|
2017-05-21 03:11:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (processor_id > THREADPROCESSORID_MAX) {
|
2018-07-02 12:13:26 -04:00
|
|
|
LOG_ERROR(Kernel_SVC, "Invalid processor id: {}", processor_id);
|
2018-09-12 04:25:53 -04:00
|
|
|
return ERR_INVALID_PROCESSOR_ID;
|
2017-05-21 03:11:36 -04:00
|
|
|
}
|
|
|
|
|
2020-02-24 21:04:12 -05:00
|
|
|
if (owner_process) {
|
|
|
|
if (!system.Memory().IsValidVirtualAddress(*owner_process, entry_point)) {
|
|
|
|
LOG_ERROR(Kernel_SVC, "(name={}): invalid entry {:016X}", name, entry_point);
|
|
|
|
// TODO (bunnei): Find the correct error code to use here
|
|
|
|
return RESULT_UNKNOWN;
|
|
|
|
}
|
2014-12-22 08:07:22 -05:00
|
|
|
}
|
2014-05-20 21:02:35 -04:00
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
std::shared_ptr<KThread> thread = std::make_shared<KThread>(kernel);
|
2014-06-05 22:35:36 -04:00
|
|
|
|
2018-08-28 12:30:33 -04:00
|
|
|
thread->thread_id = kernel.CreateNewThreadID();
|
2020-12-28 16:16:43 -05:00
|
|
|
thread->thread_state = ThreadState::Initialized;
|
2014-06-09 22:14:03 -04:00
|
|
|
thread->entry_point = entry_point;
|
|
|
|
thread->stack_top = stack_top;
|
2020-12-02 21:08:35 -05:00
|
|
|
thread->disable_count = 1;
|
2018-07-20 20:57:45 -04:00
|
|
|
thread->tpidr_el0 = 0;
|
2020-12-30 04:14:02 -05:00
|
|
|
thread->current_priority = priority;
|
|
|
|
thread->base_priority = priority;
|
|
|
|
thread->lock_owner = nullptr;
|
2020-12-02 21:08:35 -05:00
|
|
|
thread->schedule_count = -1;
|
|
|
|
thread->last_scheduled_tick = 0;
|
2014-06-09 22:14:03 -04:00
|
|
|
thread->processor_id = processor_id;
|
2018-05-07 21:57:42 -04:00
|
|
|
thread->ideal_core = processor_id;
|
2020-11-17 00:02:45 -05:00
|
|
|
thread->affinity_mask.SetAffinity(processor_id, true);
|
2014-12-29 07:55:30 -05:00
|
|
|
thread->name = std::move(name);
|
2020-02-14 08:30:53 -05:00
|
|
|
thread->global_handle = kernel.GlobalHandleTable().Create(thread).Unwrap();
|
2020-02-24 21:04:12 -05:00
|
|
|
thread->owner_process = owner_process;
|
|
|
|
thread->type = type_flags;
|
2020-12-22 01:36:53 -05:00
|
|
|
thread->signaled = false;
|
2020-02-24 21:04:12 -05:00
|
|
|
if ((type_flags & THREADTYPE_IDLE) == 0) {
|
2020-12-02 21:08:35 -05:00
|
|
|
auto& scheduler = kernel.GlobalSchedulerContext();
|
2020-02-24 21:04:12 -05:00
|
|
|
scheduler.AddThread(thread);
|
|
|
|
}
|
|
|
|
if (owner_process) {
|
|
|
|
thread->tls_address = thread->owner_process->CreateTLSRegion();
|
|
|
|
thread->owner_process->RegisterThread(thread.get());
|
|
|
|
} else {
|
|
|
|
thread->tls_address = 0;
|
|
|
|
}
|
2020-11-03 19:54:53 -05:00
|
|
|
|
2020-11-13 14:11:12 -05:00
|
|
|
// TODO(peachum): move to ScheduleThread() when scheduler is added so selected core is used
|
|
|
|
// to initialize the context
|
2020-02-24 21:04:12 -05:00
|
|
|
if ((type_flags & THREADTYPE_HLE) == 0) {
|
|
|
|
ResetThreadContext32(thread->context_32, static_cast<u32>(stack_top),
|
|
|
|
static_cast<u32>(entry_point), static_cast<u32>(arg));
|
|
|
|
ResetThreadContext64(thread->context_64, stack_top, entry_point, arg);
|
|
|
|
}
|
|
|
|
thread->host_context =
|
2020-03-07 17:59:42 -05:00
|
|
|
std::make_shared<Common::Fiber>(std::move(thread_start_func), thread_start_parameter);
|
2015-01-26 01:56:17 -05:00
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
return MakeResult<std::shared_ptr<KThread>>(std::move(thread));
|
2014-06-01 22:12:54 -04:00
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
void KThread::SetBasePriority(u32 priority) {
|
2017-01-11 12:08:10 -05:00
|
|
|
ASSERT_MSG(priority <= THREADPRIO_LOWEST && priority >= THREADPRIO_HIGHEST,
|
|
|
|
"Invalid priority value.");
|
2020-12-30 04:14:02 -05:00
|
|
|
|
|
|
|
KScopedSchedulerLock lock(kernel);
|
|
|
|
|
|
|
|
// Change our base priority.
|
|
|
|
base_priority = priority;
|
|
|
|
|
|
|
|
// Perform a priority restoration.
|
|
|
|
RestorePriority(kernel, this);
|
2014-06-01 22:12:54 -04:00
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
void KThread::SetSynchronizationResults(KSynchronizationObject* object, ResultCode result) {
|
2020-02-25 15:38:33 -05:00
|
|
|
signaling_object = object;
|
|
|
|
signaling_result = result;
|
2015-01-17 02:03:44 -05:00
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
VAddr KThread::GetCommandBufferAddress() const {
|
2017-09-29 15:47:52 -04:00
|
|
|
// Offset from the start of TLS at which the IPC command buffer begins.
|
2019-04-01 17:59:43 -04:00
|
|
|
constexpr u64 command_header_offset = 0x80;
|
|
|
|
return GetTLSAddress() + command_header_offset;
|
2017-01-04 10:53:01 -05:00
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
void KThread::SetState(ThreadState state) {
|
2020-12-30 04:14:02 -05:00
|
|
|
KScopedSchedulerLock sl(kernel);
|
|
|
|
|
2021-01-10 17:29:02 -05:00
|
|
|
// Clear debugging state
|
|
|
|
SetMutexWaitAddressForDebugging({});
|
|
|
|
SetWaitReasonForDebugging({});
|
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
const ThreadState old_state = thread_state;
|
|
|
|
thread_state =
|
|
|
|
static_cast<ThreadState>((old_state & ~ThreadState::Mask) | (state & ThreadState::Mask));
|
|
|
|
if (thread_state != old_state) {
|
|
|
|
KScheduler::OnThreadStateChanged(kernel, this, old_state);
|
2018-10-03 18:47:57 -04:00
|
|
|
}
|
2020-12-30 04:14:02 -05:00
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
void KThread::AddWaiterImpl(KThread* thread) {
|
2020-12-30 04:14:02 -05:00
|
|
|
ASSERT(kernel.GlobalSchedulerContext().IsLocked());
|
2018-10-03 18:47:57 -04:00
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
// Find the right spot to insert the waiter.
|
|
|
|
auto it = waiter_list.begin();
|
|
|
|
while (it != waiter_list.end()) {
|
|
|
|
if (it->GetPriority() > thread->GetPriority()) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
it++;
|
2019-03-29 17:01:46 -04:00
|
|
|
}
|
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
// Keep track of how many kernel waiters we have.
|
|
|
|
if (Memory::IsKernelAddressKey(thread->GetAddressKey())) {
|
|
|
|
ASSERT((num_kernel_waiters++) >= 0);
|
|
|
|
}
|
2020-12-28 16:16:43 -05:00
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
// Insert the waiter.
|
|
|
|
waiter_list.insert(it, *thread);
|
|
|
|
thread->SetLockOwner(this);
|
2018-10-03 18:47:57 -04:00
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
void KThread::RemoveWaiterImpl(KThread* thread) {
|
2020-12-30 04:14:02 -05:00
|
|
|
ASSERT(kernel.GlobalSchedulerContext().IsLocked());
|
|
|
|
|
|
|
|
// Keep track of how many kernel waiters we have.
|
|
|
|
if (Memory::IsKernelAddressKey(thread->GetAddressKey())) {
|
|
|
|
ASSERT((num_kernel_waiters--) > 0);
|
2018-08-12 17:35:27 -04:00
|
|
|
}
|
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
// Remove the waiter.
|
|
|
|
waiter_list.erase(waiter_list.iterator_to(*thread));
|
|
|
|
thread->SetLockOwner(nullptr);
|
|
|
|
}
|
2018-08-12 17:35:27 -04:00
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
void KThread::RestorePriority(KernelCore& kernel, KThread* thread) {
|
2020-12-30 04:14:02 -05:00
|
|
|
ASSERT(kernel.GlobalSchedulerContext().IsLocked());
|
2019-03-15 01:02:13 -04:00
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
while (true) {
|
|
|
|
// We want to inherit priority where possible.
|
|
|
|
s32 new_priority = thread->GetBasePriority();
|
|
|
|
if (thread->HasWaiters()) {
|
|
|
|
new_priority = std::min(new_priority, thread->waiter_list.front().GetPriority());
|
|
|
|
}
|
2019-03-15 01:02:13 -04:00
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
// If the priority we would inherit is not different from ours, don't do anything.
|
|
|
|
if (new_priority == thread->GetPriority()) {
|
|
|
|
return;
|
|
|
|
}
|
2018-04-20 21:15:16 -04:00
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
// Ensure we don't violate condition variable red black tree invariants.
|
|
|
|
if (auto* cv_tree = thread->GetConditionVariableTree(); cv_tree != nullptr) {
|
|
|
|
BeforeUpdatePriority(kernel, cv_tree, thread);
|
|
|
|
}
|
2018-08-12 17:35:27 -04:00
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
// Change the priority.
|
|
|
|
const s32 old_priority = thread->GetPriority();
|
|
|
|
thread->SetPriority(new_priority);
|
2019-03-15 01:02:13 -04:00
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
// Restore the condition variable, if relevant.
|
|
|
|
if (auto* cv_tree = thread->GetConditionVariableTree(); cv_tree != nullptr) {
|
|
|
|
AfterUpdatePriority(kernel, cv_tree, thread);
|
|
|
|
}
|
2018-08-12 17:35:27 -04:00
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
// Update the scheduler.
|
|
|
|
KScheduler::OnThreadPriorityChanged(kernel, thread, old_priority);
|
2018-04-20 21:15:16 -04:00
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
// Keep the lock owner up to date.
|
2020-12-31 02:01:08 -05:00
|
|
|
KThread* lock_owner = thread->GetLockOwner();
|
2020-12-30 04:14:02 -05:00
|
|
|
if (lock_owner == nullptr) {
|
|
|
|
return;
|
2019-03-14 21:51:03 -04:00
|
|
|
}
|
2018-04-20 21:15:16 -04:00
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
// Update the thread in the lock owner's sorted list, and continue inheriting.
|
|
|
|
lock_owner->RemoveWaiterImpl(thread);
|
|
|
|
lock_owner->AddWaiterImpl(thread);
|
|
|
|
thread = lock_owner;
|
2019-03-14 21:51:03 -04:00
|
|
|
}
|
2020-12-30 04:14:02 -05:00
|
|
|
}
|
2018-04-20 21:15:16 -04:00
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
void KThread::AddWaiter(KThread* thread) {
|
2020-12-30 04:14:02 -05:00
|
|
|
AddWaiterImpl(thread);
|
|
|
|
RestorePriority(kernel, this);
|
|
|
|
}
|
2019-11-14 19:13:18 -05:00
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
void KThread::RemoveWaiter(KThread* thread) {
|
2020-12-30 04:14:02 -05:00
|
|
|
RemoveWaiterImpl(thread);
|
|
|
|
RestorePriority(kernel, this);
|
|
|
|
}
|
2018-04-20 21:15:16 -04:00
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
KThread* KThread::RemoveWaiterByKey(s32* out_num_waiters, VAddr key) {
|
2020-12-30 04:14:02 -05:00
|
|
|
ASSERT(kernel.GlobalSchedulerContext().IsLocked());
|
2019-11-14 19:13:18 -05:00
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
s32 num_waiters{};
|
2020-12-31 02:01:08 -05:00
|
|
|
KThread* next_lock_owner{};
|
2020-12-30 04:14:02 -05:00
|
|
|
auto it = waiter_list.begin();
|
|
|
|
while (it != waiter_list.end()) {
|
|
|
|
if (it->GetAddressKey() == key) {
|
2020-12-31 02:01:08 -05:00
|
|
|
KThread* thread = std::addressof(*it);
|
2020-12-30 04:14:02 -05:00
|
|
|
|
|
|
|
// Keep track of how many kernel waiters we have.
|
|
|
|
if (Memory::IsKernelAddressKey(thread->GetAddressKey())) {
|
|
|
|
ASSERT((num_kernel_waiters--) > 0);
|
|
|
|
}
|
|
|
|
it = waiter_list.erase(it);
|
|
|
|
|
|
|
|
// Update the next lock owner.
|
|
|
|
if (next_lock_owner == nullptr) {
|
|
|
|
next_lock_owner = thread;
|
|
|
|
next_lock_owner->SetLockOwner(nullptr);
|
|
|
|
} else {
|
|
|
|
next_lock_owner->AddWaiterImpl(thread);
|
|
|
|
}
|
|
|
|
num_waiters++;
|
|
|
|
} else {
|
|
|
|
it++;
|
|
|
|
}
|
2019-03-15 01:02:13 -04:00
|
|
|
}
|
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
// Do priority updates, if we have a next owner.
|
|
|
|
if (next_lock_owner) {
|
|
|
|
RestorePriority(kernel, this);
|
|
|
|
RestorePriority(kernel, next_lock_owner);
|
|
|
|
}
|
2019-03-15 01:02:13 -04:00
|
|
|
|
2020-12-30 04:14:02 -05:00
|
|
|
// Return output.
|
|
|
|
*out_num_waiters = num_waiters;
|
|
|
|
return next_lock_owner;
|
2018-04-20 21:15:16 -04:00
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
ResultCode KThread::SetActivity(ThreadActivity value) {
|
2020-12-04 01:26:42 -05:00
|
|
|
KScopedSchedulerLock lock(kernel);
|
2020-03-07 11:44:35 -05:00
|
|
|
|
2020-12-22 01:36:53 -05:00
|
|
|
auto sched_status = GetState();
|
2020-03-07 11:44:35 -05:00
|
|
|
|
2020-12-28 16:16:43 -05:00
|
|
|
if (sched_status != ThreadState::Runnable && sched_status != ThreadState::Waiting) {
|
2020-03-07 11:44:35 -05:00
|
|
|
return ERR_INVALID_STATE;
|
|
|
|
}
|
|
|
|
|
2020-12-22 01:36:53 -05:00
|
|
|
if (IsTerminationRequested()) {
|
2020-03-07 11:44:35 -05:00
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
2018-12-03 12:25:27 -05:00
|
|
|
|
|
|
|
if (value == ThreadActivity::Paused) {
|
2020-03-07 17:59:42 -05:00
|
|
|
if ((pausing_state & static_cast<u32>(ThreadSchedFlags::ThreadPauseFlag)) != 0) {
|
2020-03-07 11:44:35 -05:00
|
|
|
return ERR_INVALID_STATE;
|
2018-12-03 12:25:27 -05:00
|
|
|
}
|
2020-03-07 11:44:35 -05:00
|
|
|
AddSchedulingFlag(ThreadSchedFlags::ThreadPauseFlag);
|
|
|
|
} else {
|
2020-03-07 17:59:42 -05:00
|
|
|
if ((pausing_state & static_cast<u32>(ThreadSchedFlags::ThreadPauseFlag)) == 0) {
|
2020-03-07 11:44:35 -05:00
|
|
|
return ERR_INVALID_STATE;
|
|
|
|
}
|
|
|
|
RemoveSchedulingFlag(ThreadSchedFlags::ThreadPauseFlag);
|
2018-12-03 12:25:27 -05:00
|
|
|
}
|
2020-03-07 11:44:35 -05:00
|
|
|
return RESULT_SUCCESS;
|
2018-12-03 12:25:27 -05:00
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
ResultCode KThread::Sleep(s64 nanoseconds) {
|
2020-02-24 21:04:12 -05:00
|
|
|
Handle event_handle{};
|
|
|
|
{
|
2020-12-04 00:56:02 -05:00
|
|
|
KScopedSchedulerLockAndSleep lock(kernel, event_handle, this, nanoseconds);
|
2020-12-28 16:16:43 -05:00
|
|
|
SetState(ThreadState::Waiting);
|
2021-01-10 17:29:02 -05:00
|
|
|
SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Sleep);
|
2020-02-24 21:04:12 -05:00
|
|
|
}
|
2019-03-15 23:28:29 -04:00
|
|
|
|
2020-02-24 21:04:12 -05:00
|
|
|
if (event_handle != InvalidHandle) {
|
|
|
|
auto& time_manager = kernel.TimeManager();
|
|
|
|
time_manager.UnscheduleTimeEvent(event_handle);
|
|
|
|
}
|
2020-02-25 11:40:33 -05:00
|
|
|
return RESULT_SUCCESS;
|
2019-03-15 23:28:29 -04:00
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
void KThread::AddSchedulingFlag(ThreadSchedFlags flag) {
|
2020-12-28 16:16:43 -05:00
|
|
|
const auto old_state = GetRawState();
|
2020-03-07 11:44:35 -05:00
|
|
|
pausing_state |= static_cast<u32>(flag);
|
2020-12-28 16:16:43 -05:00
|
|
|
const auto base_scheduling = GetState();
|
|
|
|
thread_state = base_scheduling | static_cast<ThreadState>(pausing_state);
|
2020-12-02 21:08:35 -05:00
|
|
|
KScheduler::OnThreadStateChanged(kernel, this, old_state);
|
2020-03-07 11:44:35 -05:00
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
void KThread::RemoveSchedulingFlag(ThreadSchedFlags flag) {
|
2020-12-28 16:16:43 -05:00
|
|
|
const auto old_state = GetRawState();
|
2020-03-07 11:44:35 -05:00
|
|
|
pausing_state &= ~static_cast<u32>(flag);
|
2020-12-28 16:16:43 -05:00
|
|
|
const auto base_scheduling = GetState();
|
|
|
|
thread_state = base_scheduling | static_cast<ThreadState>(pausing_state);
|
2020-12-02 21:08:35 -05:00
|
|
|
KScheduler::OnThreadStateChanged(kernel, this, old_state);
|
2020-03-07 11:44:35 -05:00
|
|
|
}
|
|
|
|
|
2020-12-31 02:01:08 -05:00
|
|
|
ResultCode KThread::SetCoreAndAffinityMask(s32 new_core, u64 new_affinity_mask) {
|
2020-12-04 01:26:42 -05:00
|
|
|
KScopedSchedulerLock lock(kernel);
|
2019-06-19 09:11:18 -04:00
|
|
|
const auto HighestSetCore = [](u64 mask, u32 max_cores) {
|
2019-11-12 03:32:53 -05:00
|
|
|
for (s32 core = static_cast<s32>(max_cores - 1); core >= 0; core--) {
|
2019-06-19 09:11:18 -04:00
|
|
|
if (((mask >> core) & 1) != 0) {
|
2019-03-29 17:01:46 -04:00
|
|
|
return core;
|
2019-06-19 09:11:18 -04:00
|
|
|
}
|
2019-03-29 17:01:46 -04:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
};
|
2019-06-19 09:11:18 -04:00
|
|
|
|
|
|
|
const bool use_override = affinity_override_count != 0;
|
2019-10-12 10:55:34 -04:00
|
|
|
if (new_core == THREADPROCESSORID_DONT_UPDATE) {
|
2019-03-29 17:01:46 -04:00
|
|
|
new_core = use_override ? ideal_core_override : ideal_core;
|
2019-10-12 10:13:25 -04:00
|
|
|
if ((new_affinity_mask & (1ULL << new_core)) == 0) {
|
2020-04-29 00:53:53 -04:00
|
|
|
LOG_ERROR(Kernel, "New affinity mask is incorrect! new_core={}, new_affinity_mask={}",
|
|
|
|
new_core, new_affinity_mask);
|
2019-03-29 17:01:46 -04:00
|
|
|
return ERR_INVALID_COMBINATION;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (use_override) {
|
|
|
|
ideal_core_override = new_core;
|
|
|
|
} else {
|
2020-12-02 21:08:35 -05:00
|
|
|
const auto old_affinity_mask = affinity_mask;
|
2020-11-17 00:02:45 -05:00
|
|
|
affinity_mask.SetAffinityMask(new_affinity_mask);
|
2019-03-29 17:01:46 -04:00
|
|
|
ideal_core = new_core;
|
2020-12-02 21:08:35 -05:00
|
|
|
if (old_affinity_mask.GetAffinityMask() != new_affinity_mask) {
|
2019-06-19 09:11:18 -04:00
|
|
|
const s32 old_core = processor_id;
|
2020-11-17 00:02:45 -05:00
|
|
|
if (processor_id >= 0 && !affinity_mask.GetAffinity(processor_id)) {
|
2020-10-20 22:07:39 -04:00
|
|
|
if (static_cast<s32>(ideal_core) < 0) {
|
2020-11-17 00:02:45 -05:00
|
|
|
processor_id = HighestSetCore(affinity_mask.GetAffinityMask(),
|
|
|
|
Core::Hardware::NUM_CPU_CORES);
|
2019-03-29 17:01:46 -04:00
|
|
|
} else {
|
|
|
|
processor_id = ideal_core;
|
|
|
|
}
|
|
|
|
}
|
2020-12-02 21:08:35 -05:00
|
|
|
KScheduler::OnThreadAffinityMaskChanged(kernel, this, old_affinity_mask, old_core);
|
2019-03-29 17:01:46 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2018-01-08 11:35:03 -05:00
|
|
|
} // namespace Kernel
|