2014-05-09 19:11:18 -07:00
|
|
|
// Copyright 2014 Citra Emulator Project / PPSSPP Project
|
2014-12-16 21:38:14 -08:00
|
|
|
// Licensed under GPLv2 or any later version
|
2014-11-19 00:49:13 -08:00
|
|
|
// Refer to the license.txt file included.
|
2014-05-09 19:11:18 -07:00
|
|
|
|
2014-06-05 19:35:36 -07:00
|
|
|
#include <algorithm>
|
2018-02-13 21:33:15 -08:00
|
|
|
#include <cinttypes>
|
2018-10-29 21:03:25 -07:00
|
|
|
#include <optional>
|
2014-08-17 20:03:22 -07:00
|
|
|
#include <vector>
|
2018-07-31 05:06:09 -07:00
|
|
|
|
2015-05-06 00:06:12 -07:00
|
|
|
#include "common/assert.h"
|
|
|
|
#include "common/common_types.h"
|
2020-02-24 18:04:12 -08:00
|
|
|
#include "common/fiber.h"
|
2015-05-06 00:06:12 -07:00
|
|
|
#include "common/logging/log.h"
|
2014-05-15 15:27:08 -07:00
|
|
|
#include "common/thread_queue_list.h"
|
2014-05-13 19:00:11 -07:00
|
|
|
#include "core/core.h"
|
2020-02-24 18:04:12 -08:00
|
|
|
#include "core/cpu_manager.h"
|
2020-02-11 15:56:24 -08:00
|
|
|
#include "core/hardware_properties.h"
|
2017-05-21 00:11:36 -07:00
|
|
|
#include "core/hle/kernel/errors.h"
|
2017-05-29 16:45:42 -07:00
|
|
|
#include "core/hle/kernel/handle_table.h"
|
2020-12-02 18:08:35 -08:00
|
|
|
#include "core/hle/kernel/k_scheduler.h"
|
2020-12-03 21:56:02 -08:00
|
|
|
#include "core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h"
|
2018-08-28 09:30:33 -07:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
2018-08-01 19:40:00 -07:00
|
|
|
#include "core/hle/kernel/object.h"
|
2016-09-17 17:38:01 -07:00
|
|
|
#include "core/hle/kernel/process.h"
|
2016-09-20 23:52:38 -07:00
|
|
|
#include "core/hle/kernel/thread.h"
|
2020-02-24 18:04:12 -08:00
|
|
|
#include "core/hle/kernel/time_manager.h"
|
2014-10-22 20:20:01 -07:00
|
|
|
#include "core/hle/result.h"
|
2015-05-12 18:38:29 -07:00
|
|
|
#include "core/memory.h"
|
2014-05-09 19:11:18 -07:00
|
|
|
|
2020-07-15 10:13:31 -07: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 16:37:46 -07:00
|
|
|
namespace Kernel {
|
2014-05-13 19:00:11 -07:00
|
|
|
|
2020-02-11 13:36:39 -08:00
|
|
|
bool Thread::IsSignaled() const {
|
2020-12-21 22:36:53 -08:00
|
|
|
return signaled;
|
2020-02-11 13:36:39 -08:00
|
|
|
}
|
|
|
|
|
2020-12-21 22:36:53 -08:00
|
|
|
Thread::Thread(KernelCore& kernel) : KSynchronizationObject{kernel} {}
|
2018-08-28 09:30:33 -07:00
|
|
|
Thread::~Thread() = default;
|
2015-01-31 13:22:40 -08:00
|
|
|
|
2015-01-25 22:56:17 -08:00
|
|
|
void Thread::Stop() {
|
2020-03-03 09:02:50 -08:00
|
|
|
{
|
2020-12-03 22:26:42 -08:00
|
|
|
KScopedSchedulerLock lock(kernel);
|
2020-12-21 22:36:53 -08:00
|
|
|
SetState(ThreadStatus::Dead);
|
|
|
|
signaled = true;
|
|
|
|
NotifyAvailable();
|
2020-03-03 09:37:11 -08:00
|
|
|
kernel.GlobalHandleTable().Close(global_handle);
|
2020-03-03 09:02:50 -08:00
|
|
|
|
2020-03-11 17:44:53 -07:00
|
|
|
if (owner_process) {
|
|
|
|
owner_process->UnregisterThread(this);
|
2020-03-03 09:02:50 -08:00
|
|
|
|
2020-03-11 17:44:53 -07:00
|
|
|
// Mark the TLS slot in the thread's page as free.
|
|
|
|
owner_process->FreeTLSRegion(tls_address);
|
|
|
|
}
|
2020-03-07 10:16:25 -08:00
|
|
|
has_exited = true;
|
2020-03-03 09:02:50 -08:00
|
|
|
}
|
2020-02-14 05:30:53 -08:00
|
|
|
global_handle = 0;
|
2014-05-13 19:00:11 -07:00
|
|
|
}
|
|
|
|
|
2020-12-21 22:36:53 -08:00
|
|
|
void Thread::Wakeup() {
|
2020-12-03 22:26:42 -08:00
|
|
|
KScopedSchedulerLock lock(kernel);
|
2015-01-25 22:56:17 -08:00
|
|
|
switch (status) {
|
2020-04-15 10:48:14 -07:00
|
|
|
case ThreadStatus::Paused:
|
2019-04-17 04:21:19 -07:00
|
|
|
case ThreadStatus::WaitSynch:
|
2018-07-19 18:39:05 -07:00
|
|
|
case ThreadStatus::WaitHLEEvent:
|
|
|
|
case ThreadStatus::WaitSleep:
|
|
|
|
case ThreadStatus::WaitIPC:
|
|
|
|
case ThreadStatus::WaitMutex:
|
2019-03-13 16:55:04 -07:00
|
|
|
case ThreadStatus::WaitCondVar:
|
2018-07-19 18:39:05 -07:00
|
|
|
case ThreadStatus::WaitArb:
|
2020-04-15 10:48:14 -07:00
|
|
|
case ThreadStatus::Dormant:
|
2016-09-17 17:38:01 -07:00
|
|
|
break;
|
|
|
|
|
2018-07-19 18:39:05 -07:00
|
|
|
case ThreadStatus::Ready:
|
2016-09-17 17:38:01 -07:00
|
|
|
// If the thread is waiting on multiple wait objects, it might be awoken more than once
|
|
|
|
// before actually resuming. We can ignore subsequent wakeups if the thread status has
|
2018-07-19 18:39:05 -07:00
|
|
|
// already been set to ThreadStatus::Ready.
|
2016-09-17 17:38:01 -07:00
|
|
|
return;
|
2018-07-19 18:39:05 -07:00
|
|
|
case ThreadStatus::Dead:
|
2016-09-17 17:38:01 -07:00
|
|
|
// This should never happen, as threads must complete before being stopped.
|
2018-04-27 04:54:05 -07:00
|
|
|
DEBUG_ASSERT_MSG(false, "Thread with object id {} cannot be resumed because it's DEAD.",
|
2016-09-17 17:38:01 -07:00
|
|
|
GetObjectId());
|
|
|
|
return;
|
2014-05-20 16:37:46 -07:00
|
|
|
}
|
2015-05-25 11:34:09 -07:00
|
|
|
|
2020-12-21 22:36:53 -08:00
|
|
|
SetState(ThreadStatus::Ready);
|
2014-05-20 16:37:46 -07:00
|
|
|
}
|
|
|
|
|
2020-02-24 18:04:12 -08:00
|
|
|
void Thread::OnWakeUp() {
|
2020-12-03 22:26:42 -08:00
|
|
|
KScopedSchedulerLock lock(kernel);
|
2020-12-21 22:36:53 -08:00
|
|
|
SetState(ThreadStatus::Ready);
|
2020-02-24 18:04:12 -08:00
|
|
|
}
|
|
|
|
|
2020-02-25 08:40:33 -08:00
|
|
|
ResultCode Thread::Start() {
|
2020-12-03 22:26:42 -08:00
|
|
|
KScopedSchedulerLock lock(kernel);
|
2020-12-21 22:36:53 -08:00
|
|
|
SetState(ThreadStatus::Ready);
|
2020-02-25 08:40:33 -08:00
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2019-04-17 04:08:12 -07:00
|
|
|
void Thread::CancelWait() {
|
2020-12-03 22:26:42 -08:00
|
|
|
KScopedSchedulerLock lock(kernel);
|
2020-12-21 22:36:53 -08:00
|
|
|
if (GetState() != ThreadSchedStatus::Paused || !is_cancellable) {
|
2019-11-16 07:05:39 -08:00
|
|
|
is_sync_cancelled = true;
|
|
|
|
return;
|
|
|
|
}
|
2020-03-07 08:44:35 -08:00
|
|
|
// TODO(Blinkhawk): Implement cancel of server session
|
2019-11-16 07:05:39 -08:00
|
|
|
is_sync_cancelled = false;
|
2020-02-25 12:38:33 -08:00
|
|
|
SetSynchronizationResults(nullptr, ERR_SYNCHRONIZATION_CANCELED);
|
2020-12-21 22:36:53 -08:00
|
|
|
SetState(ThreadStatus::Ready);
|
2019-04-17 04:08:12 -07:00
|
|
|
}
|
|
|
|
|
2020-03-01 20:46:10 -08: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 07:57:28 -07:00
|
|
|
context = {};
|
2016-09-02 05:53:42 -07:00
|
|
|
context.cpu_registers[0] = arg;
|
|
|
|
context.pc = entry_point;
|
|
|
|
context.sp = stack_top;
|
2018-12-17 15:04:02 -08:00
|
|
|
// TODO(merry): Perform a hardware test to determine the below value.
|
2020-04-19 00:37:20 -07:00
|
|
|
context.fpcr = 0;
|
2016-09-02 05:53:42 -07:00
|
|
|
}
|
|
|
|
|
2020-05-13 11:17:34 -07:00
|
|
|
std::shared_ptr<Common::Fiber>& Thread::GetHostContext() {
|
2020-02-24 18:04:12 -08:00
|
|
|
return host_context;
|
|
|
|
}
|
|
|
|
|
|
|
|
ResultVal<std::shared_ptr<Thread>> Thread::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 10:28:10 -07:00
|
|
|
std::function<void(void*)> init_func = Core::CpuManager::GetGuestThreadStartFunc();
|
2020-02-24 18:04:12 -08: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);
|
|
|
|
}
|
|
|
|
|
|
|
|
ResultVal<std::shared_ptr<Thread>> Thread::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) {
|
|
|
|
auto& kernel = system.Kernel();
|
2017-05-21 00:11:36 -07:00
|
|
|
// Check if priority is in ranged. Lowest priority -> highest priority id.
|
2020-02-25 08:40:33 -08:00
|
|
|
if (priority > THREADPRIO_LOWEST && ((type_flags & THREADTYPE_IDLE) == 0)) {
|
2018-07-02 09:13:26 -07:00
|
|
|
LOG_ERROR(Kernel_SVC, "Invalid thread priority: {}", priority);
|
2018-09-12 01:25:53 -07:00
|
|
|
return ERR_INVALID_THREAD_PRIORITY;
|
2017-05-21 00:11:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (processor_id > THREADPROCESSORID_MAX) {
|
2018-07-02 09:13:26 -07:00
|
|
|
LOG_ERROR(Kernel_SVC, "Invalid processor id: {}", processor_id);
|
2018-09-12 01:25:53 -07:00
|
|
|
return ERR_INVALID_PROCESSOR_ID;
|
2017-05-21 00:11:36 -07:00
|
|
|
}
|
|
|
|
|
2020-02-24 18:04:12 -08: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 05:07:22 -08:00
|
|
|
}
|
2014-05-20 18:02:35 -07:00
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
std::shared_ptr<Thread> thread = std::make_shared<Thread>(kernel);
|
2014-06-05 19:35:36 -07:00
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
thread->thread_id = kernel.CreateNewThreadID();
|
2018-07-19 18:39:05 -07:00
|
|
|
thread->status = ThreadStatus::Dormant;
|
2014-06-09 19:14:03 -07:00
|
|
|
thread->entry_point = entry_point;
|
|
|
|
thread->stack_top = stack_top;
|
2020-12-02 18:08:35 -08:00
|
|
|
thread->disable_count = 1;
|
2018-07-20 17:57:45 -07:00
|
|
|
thread->tpidr_el0 = 0;
|
2015-03-23 20:55:21 -07:00
|
|
|
thread->nominal_priority = thread->current_priority = priority;
|
2020-12-02 18:08:35 -08:00
|
|
|
thread->schedule_count = -1;
|
|
|
|
thread->last_scheduled_tick = 0;
|
2014-06-09 19:14:03 -07:00
|
|
|
thread->processor_id = processor_id;
|
2018-05-07 18:57:42 -07:00
|
|
|
thread->ideal_core = processor_id;
|
2020-11-16 21:02:45 -08:00
|
|
|
thread->affinity_mask.SetAffinity(processor_id, true);
|
2018-04-20 10:01:14 -07:00
|
|
|
thread->mutex_wait_address = 0;
|
|
|
|
thread->condvar_wait_address = 0;
|
|
|
|
thread->wait_handle = 0;
|
2014-12-29 04:55:30 -08:00
|
|
|
thread->name = std::move(name);
|
2020-02-14 05:30:53 -08:00
|
|
|
thread->global_handle = kernel.GlobalHandleTable().Create(thread).Unwrap();
|
2020-02-24 18:04:12 -08:00
|
|
|
thread->owner_process = owner_process;
|
|
|
|
thread->type = type_flags;
|
2020-12-21 22:36:53 -08:00
|
|
|
thread->signaled = false;
|
2020-02-24 18:04:12 -08:00
|
|
|
if ((type_flags & THREADTYPE_IDLE) == 0) {
|
2020-12-02 18:08:35 -08:00
|
|
|
auto& scheduler = kernel.GlobalSchedulerContext();
|
2020-02-24 18:04:12 -08: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 16:54:53 -08:00
|
|
|
|
2020-11-13 11:11:12 -08:00
|
|
|
// TODO(peachum): move to ScheduleThread() when scheduler is added so selected core is used
|
|
|
|
// to initialize the context
|
2020-02-24 18:04:12 -08: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 14:59:42 -08:00
|
|
|
std::make_shared<Common::Fiber>(std::move(thread_start_func), thread_start_parameter);
|
2015-01-25 22:56:17 -08:00
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
return MakeResult<std::shared_ptr<Thread>>(std::move(thread));
|
2014-06-01 19:12:54 -07:00
|
|
|
}
|
|
|
|
|
2017-09-26 16:26:09 -07:00
|
|
|
void Thread::SetPriority(u32 priority) {
|
2020-12-03 22:26:42 -08:00
|
|
|
KScopedSchedulerLock lock(kernel);
|
2017-01-11 09:08:10 -08:00
|
|
|
ASSERT_MSG(priority <= THREADPRIO_LOWEST && priority >= THREADPRIO_HIGHEST,
|
|
|
|
"Invalid priority value.");
|
2018-04-20 18:15:16 -07:00
|
|
|
nominal_priority = priority;
|
|
|
|
UpdatePriority();
|
2014-06-01 19:12:54 -07:00
|
|
|
}
|
|
|
|
|
2020-12-21 22:36:53 -08:00
|
|
|
void Thread::SetSynchronizationResults(KSynchronizationObject* object, ResultCode result) {
|
2020-02-25 12:38:33 -08:00
|
|
|
signaling_object = object;
|
|
|
|
signaling_result = result;
|
2015-01-16 23:03:44 -08:00
|
|
|
}
|
|
|
|
|
2017-09-29 12:47:52 -07:00
|
|
|
VAddr Thread::GetCommandBufferAddress() const {
|
|
|
|
// Offset from the start of TLS at which the IPC command buffer begins.
|
2019-04-01 14:59:43 -07:00
|
|
|
constexpr u64 command_header_offset = 0x80;
|
|
|
|
return GetTLSAddress() + command_header_offset;
|
2017-01-04 07:53:01 -08:00
|
|
|
}
|
|
|
|
|
2020-12-21 22:36:53 -08:00
|
|
|
void Thread::SetState(ThreadStatus new_status) {
|
2018-10-03 15:47:57 -07:00
|
|
|
if (new_status == status) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-03-29 14:01:46 -07:00
|
|
|
switch (new_status) {
|
|
|
|
case ThreadStatus::Ready:
|
|
|
|
SetSchedulingStatus(ThreadSchedStatus::Runnable);
|
|
|
|
break;
|
|
|
|
case ThreadStatus::Dormant:
|
|
|
|
SetSchedulingStatus(ThreadSchedStatus::None);
|
|
|
|
break;
|
|
|
|
case ThreadStatus::Dead:
|
|
|
|
SetSchedulingStatus(ThreadSchedStatus::Exited);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
SetSchedulingStatus(ThreadSchedStatus::Paused);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2018-10-03 15:47:57 -07:00
|
|
|
status = new_status;
|
|
|
|
}
|
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
void Thread::AddMutexWaiter(std::shared_ptr<Thread> thread) {
|
|
|
|
if (thread->lock_owner.get() == this) {
|
2018-08-12 14:35:27 -07:00
|
|
|
// If the thread is already waiting for this thread to release the mutex, ensure that the
|
|
|
|
// waiters list is consistent and return without doing anything.
|
2019-03-14 22:02:13 -07:00
|
|
|
const auto iter = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
|
|
|
|
ASSERT(iter != wait_mutex_threads.end());
|
2018-08-12 14:35:27 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// A thread can't wait on two different mutexes at the same time.
|
|
|
|
ASSERT(thread->lock_owner == nullptr);
|
|
|
|
|
|
|
|
// Ensure that the thread is not already in the list of mutex waiters
|
2019-03-14 22:02:13 -07:00
|
|
|
const auto iter = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
|
|
|
|
ASSERT(iter == wait_mutex_threads.end());
|
|
|
|
|
|
|
|
// Keep the list in an ordered fashion
|
|
|
|
const auto insertion_point = std::find_if(
|
|
|
|
wait_mutex_threads.begin(), wait_mutex_threads.end(),
|
|
|
|
[&thread](const auto& entry) { return entry->GetPriority() > thread->GetPriority(); });
|
|
|
|
wait_mutex_threads.insert(insertion_point, thread);
|
2019-11-24 17:15:51 -08:00
|
|
|
thread->lock_owner = SharedFrom(this);
|
2019-03-14 22:02:13 -07:00
|
|
|
|
2018-04-20 18:15:16 -07:00
|
|
|
UpdatePriority();
|
|
|
|
}
|
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
void Thread::RemoveMutexWaiter(std::shared_ptr<Thread> thread) {
|
|
|
|
ASSERT(thread->lock_owner.get() == this);
|
2018-08-12 14:35:27 -07:00
|
|
|
|
|
|
|
// Ensure that the thread is in the list of mutex waiters
|
2019-03-14 22:02:13 -07:00
|
|
|
const auto iter = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
|
|
|
|
ASSERT(iter != wait_mutex_threads.end());
|
|
|
|
|
|
|
|
wait_mutex_threads.erase(iter);
|
2018-08-12 14:35:27 -07:00
|
|
|
|
2018-04-20 18:15:16 -07:00
|
|
|
thread->lock_owner = nullptr;
|
|
|
|
UpdatePriority();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Thread::UpdatePriority() {
|
2019-03-14 18:58:23 -07:00
|
|
|
// If any of the threads waiting on the mutex have a higher priority
|
|
|
|
// (taking into account priority inheritance), then this thread inherits
|
|
|
|
// that thread's priority.
|
2018-04-20 18:15:16 -07:00
|
|
|
u32 new_priority = nominal_priority;
|
2019-03-14 18:47:46 -07:00
|
|
|
if (!wait_mutex_threads.empty()) {
|
2019-03-14 18:51:03 -07:00
|
|
|
if (wait_mutex_threads.front()->current_priority < new_priority) {
|
2019-03-14 18:47:46 -07:00
|
|
|
new_priority = wait_mutex_threads.front()->current_priority;
|
2019-03-14 18:51:03 -07:00
|
|
|
}
|
2018-04-20 18:15:16 -07:00
|
|
|
}
|
|
|
|
|
2019-03-14 18:51:03 -07:00
|
|
|
if (new_priority == current_priority) {
|
2018-04-20 18:15:16 -07:00
|
|
|
return;
|
2019-03-14 18:51:03 -07:00
|
|
|
}
|
2018-04-20 18:15:16 -07:00
|
|
|
|
2019-11-14 16:13:18 -08:00
|
|
|
if (GetStatus() == ThreadStatus::WaitCondVar) {
|
2019-11-24 17:15:51 -08:00
|
|
|
owner_process->RemoveConditionVariableThread(SharedFrom(this));
|
2019-11-14 16:13:18 -08:00
|
|
|
}
|
|
|
|
|
2019-03-29 14:01:46 -07:00
|
|
|
SetCurrentPriority(new_priority);
|
2018-04-20 18:15:16 -07:00
|
|
|
|
2019-11-14 16:13:18 -08:00
|
|
|
if (GetStatus() == ThreadStatus::WaitCondVar) {
|
2019-11-24 17:15:51 -08:00
|
|
|
owner_process->InsertConditionVariableThread(SharedFrom(this));
|
2019-11-14 16:13:18 -08:00
|
|
|
}
|
|
|
|
|
2019-03-14 22:02:13 -07:00
|
|
|
if (!lock_owner) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ensure that the thread is within the correct location in the waiting list.
|
2019-03-19 19:45:34 -07:00
|
|
|
auto old_owner = lock_owner;
|
2019-11-24 17:15:51 -08:00
|
|
|
lock_owner->RemoveMutexWaiter(SharedFrom(this));
|
|
|
|
old_owner->AddMutexWaiter(SharedFrom(this));
|
2019-03-14 22:02:13 -07:00
|
|
|
|
2018-04-20 18:15:16 -07:00
|
|
|
// Recursively update the priority of the thread that depends on the priority of this one.
|
2019-03-14 22:02:13 -07:00
|
|
|
lock_owner->UpdatePriority();
|
2018-04-20 18:15:16 -07:00
|
|
|
}
|
|
|
|
|
2020-03-07 08:44:35 -08:00
|
|
|
ResultCode Thread::SetActivity(ThreadActivity value) {
|
2020-12-03 22:26:42 -08:00
|
|
|
KScopedSchedulerLock lock(kernel);
|
2020-03-07 08:44:35 -08:00
|
|
|
|
2020-12-21 22:36:53 -08:00
|
|
|
auto sched_status = GetState();
|
2020-03-07 08:44:35 -08:00
|
|
|
|
|
|
|
if (sched_status != ThreadSchedStatus::Runnable && sched_status != ThreadSchedStatus::Paused) {
|
|
|
|
return ERR_INVALID_STATE;
|
|
|
|
}
|
|
|
|
|
2020-12-21 22:36:53 -08:00
|
|
|
if (IsTerminationRequested()) {
|
2020-03-07 08:44:35 -08:00
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
2018-12-03 09:25:27 -08:00
|
|
|
|
|
|
|
if (value == ThreadActivity::Paused) {
|
2020-03-07 14:59:42 -08:00
|
|
|
if ((pausing_state & static_cast<u32>(ThreadSchedFlags::ThreadPauseFlag)) != 0) {
|
2020-03-07 08:44:35 -08:00
|
|
|
return ERR_INVALID_STATE;
|
2018-12-03 09:25:27 -08:00
|
|
|
}
|
2020-03-07 08:44:35 -08:00
|
|
|
AddSchedulingFlag(ThreadSchedFlags::ThreadPauseFlag);
|
|
|
|
} else {
|
2020-03-07 14:59:42 -08:00
|
|
|
if ((pausing_state & static_cast<u32>(ThreadSchedFlags::ThreadPauseFlag)) == 0) {
|
2020-03-07 08:44:35 -08:00
|
|
|
return ERR_INVALID_STATE;
|
|
|
|
}
|
|
|
|
RemoveSchedulingFlag(ThreadSchedFlags::ThreadPauseFlag);
|
2018-12-03 09:25:27 -08:00
|
|
|
}
|
2020-03-07 08:44:35 -08:00
|
|
|
return RESULT_SUCCESS;
|
2018-12-03 09:25:27 -08:00
|
|
|
}
|
|
|
|
|
2020-02-25 08:40:33 -08:00
|
|
|
ResultCode Thread::Sleep(s64 nanoseconds) {
|
2020-02-24 18:04:12 -08:00
|
|
|
Handle event_handle{};
|
|
|
|
{
|
2020-12-03 21:56:02 -08:00
|
|
|
KScopedSchedulerLockAndSleep lock(kernel, event_handle, this, nanoseconds);
|
2020-12-21 22:36:53 -08:00
|
|
|
SetState(ThreadStatus::WaitSleep);
|
2020-02-24 18:04:12 -08:00
|
|
|
}
|
2019-03-15 20:28:29 -07:00
|
|
|
|
2020-02-24 18:04:12 -08:00
|
|
|
if (event_handle != InvalidHandle) {
|
|
|
|
auto& time_manager = kernel.TimeManager();
|
|
|
|
time_manager.UnscheduleTimeEvent(event_handle);
|
|
|
|
}
|
2020-02-25 08:40:33 -08:00
|
|
|
return RESULT_SUCCESS;
|
2019-03-15 20:28:29 -07:00
|
|
|
}
|
|
|
|
|
2020-03-07 08:44:35 -08:00
|
|
|
void Thread::AddSchedulingFlag(ThreadSchedFlags flag) {
|
|
|
|
const u32 old_state = scheduling_state;
|
|
|
|
pausing_state |= static_cast<u32>(flag);
|
2020-12-21 22:36:53 -08:00
|
|
|
const u32 base_scheduling = static_cast<u32>(GetState());
|
2020-03-07 08:44:35 -08:00
|
|
|
scheduling_state = base_scheduling | pausing_state;
|
2020-12-02 18:08:35 -08:00
|
|
|
KScheduler::OnThreadStateChanged(kernel, this, old_state);
|
2020-03-07 08:44:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Thread::RemoveSchedulingFlag(ThreadSchedFlags flag) {
|
|
|
|
const u32 old_state = scheduling_state;
|
|
|
|
pausing_state &= ~static_cast<u32>(flag);
|
2020-12-21 22:36:53 -08:00
|
|
|
const u32 base_scheduling = static_cast<u32>(GetState());
|
2020-03-07 08:44:35 -08:00
|
|
|
scheduling_state = base_scheduling | pausing_state;
|
2020-12-02 18:08:35 -08:00
|
|
|
KScheduler::OnThreadStateChanged(kernel, this, old_state);
|
2020-03-07 08:44:35 -08:00
|
|
|
}
|
|
|
|
|
2019-03-29 14:01:46 -07:00
|
|
|
void Thread::SetSchedulingStatus(ThreadSchedStatus new_status) {
|
2020-03-07 08:44:35 -08:00
|
|
|
const u32 old_state = scheduling_state;
|
2019-10-12 07:13:25 -07:00
|
|
|
scheduling_state = (scheduling_state & static_cast<u32>(ThreadSchedMasks::HighMask)) |
|
|
|
|
static_cast<u32>(new_status);
|
2020-12-02 18:08:35 -08:00
|
|
|
KScheduler::OnThreadStateChanged(kernel, this, old_state);
|
2019-03-29 14:01:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void Thread::SetCurrentPriority(u32 new_priority) {
|
2019-10-12 07:13:25 -07:00
|
|
|
const u32 old_priority = std::exchange(current_priority, new_priority);
|
2020-12-02 18:08:35 -08:00
|
|
|
KScheduler::OnThreadPriorityChanged(kernel, this, kernel.CurrentScheduler()->GetCurrentThread(),
|
|
|
|
old_priority);
|
2019-03-29 14:01:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
ResultCode Thread::SetCoreAndAffinityMask(s32 new_core, u64 new_affinity_mask) {
|
2020-12-03 22:26:42 -08:00
|
|
|
KScopedSchedulerLock lock(kernel);
|
2019-06-19 06:11:18 -07:00
|
|
|
const auto HighestSetCore = [](u64 mask, u32 max_cores) {
|
2019-11-12 00:32:53 -08:00
|
|
|
for (s32 core = static_cast<s32>(max_cores - 1); core >= 0; core--) {
|
2019-06-19 06:11:18 -07:00
|
|
|
if (((mask >> core) & 1) != 0) {
|
2019-03-29 14:01:46 -07:00
|
|
|
return core;
|
2019-06-19 06:11:18 -07:00
|
|
|
}
|
2019-03-29 14:01:46 -07:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
};
|
2019-06-19 06:11:18 -07:00
|
|
|
|
|
|
|
const bool use_override = affinity_override_count != 0;
|
2019-10-12 07:55:34 -07:00
|
|
|
if (new_core == THREADPROCESSORID_DONT_UPDATE) {
|
2019-03-29 14:01:46 -07:00
|
|
|
new_core = use_override ? ideal_core_override : ideal_core;
|
2019-10-12 07:13:25 -07:00
|
|
|
if ((new_affinity_mask & (1ULL << new_core)) == 0) {
|
2020-04-28 21:53:53 -07:00
|
|
|
LOG_ERROR(Kernel, "New affinity mask is incorrect! new_core={}, new_affinity_mask={}",
|
|
|
|
new_core, new_affinity_mask);
|
2019-03-29 14:01:46 -07:00
|
|
|
return ERR_INVALID_COMBINATION;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (use_override) {
|
|
|
|
ideal_core_override = new_core;
|
|
|
|
} else {
|
2020-12-02 18:08:35 -08:00
|
|
|
const auto old_affinity_mask = affinity_mask;
|
2020-11-16 21:02:45 -08:00
|
|
|
affinity_mask.SetAffinityMask(new_affinity_mask);
|
2019-03-29 14:01:46 -07:00
|
|
|
ideal_core = new_core;
|
2020-12-02 18:08:35 -08:00
|
|
|
if (old_affinity_mask.GetAffinityMask() != new_affinity_mask) {
|
2019-06-19 06:11:18 -07:00
|
|
|
const s32 old_core = processor_id;
|
2020-11-16 21:02:45 -08:00
|
|
|
if (processor_id >= 0 && !affinity_mask.GetAffinity(processor_id)) {
|
2020-10-20 19:07:39 -07:00
|
|
|
if (static_cast<s32>(ideal_core) < 0) {
|
2020-11-16 21:02:45 -08:00
|
|
|
processor_id = HighestSetCore(affinity_mask.GetAffinityMask(),
|
|
|
|
Core::Hardware::NUM_CPU_CORES);
|
2019-03-29 14:01:46 -07:00
|
|
|
} else {
|
|
|
|
processor_id = ideal_core;
|
|
|
|
}
|
|
|
|
}
|
2020-12-02 18:08:35 -08:00
|
|
|
KScheduler::OnThreadAffinityMaskChanged(kernel, this, old_affinity_mask, old_core);
|
2019-03-29 14:01:46 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2018-01-08 08:35:03 -08:00
|
|
|
} // namespace Kernel
|