2014-12-16 21:38:14 -08:00
|
|
|
// Copyright 2014 Citra Emulator Project
|
|
|
|
// 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
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
#include <atomic>
|
2020-01-26 06:28:23 -08:00
|
|
|
#include <functional>
|
2018-08-28 09:30:33 -07:00
|
|
|
#include <memory>
|
|
|
|
#include <mutex>
|
|
|
|
#include <utility>
|
|
|
|
|
|
|
|
#include "common/assert.h"
|
|
|
|
#include "common/logging/log.h"
|
2020-01-25 14:55:32 -08:00
|
|
|
#include "core/arm/arm_interface.h"
|
|
|
|
#include "core/arm/exclusive_monitor.h"
|
2018-08-28 09:30:33 -07:00
|
|
|
#include "core/core.h"
|
|
|
|
#include "core/core_timing.h"
|
2019-09-10 08:04:40 -07:00
|
|
|
#include "core/core_timing_util.h"
|
2018-09-02 08:58:58 -07:00
|
|
|
#include "core/hle/kernel/client_port.h"
|
2019-10-07 15:57:13 -07:00
|
|
|
#include "core/hle/kernel/errors.h"
|
2017-05-29 16:45:42 -07:00
|
|
|
#include "core/hle/kernel/handle_table.h"
|
2016-09-20 23:52:38 -07:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
2020-01-25 14:55:32 -08:00
|
|
|
#include "core/hle/kernel/physical_core.h"
|
2015-05-03 20:01:16 -07:00
|
|
|
#include "core/hle/kernel/process.h"
|
2015-08-05 17:26:52 -07:00
|
|
|
#include "core/hle/kernel/resource_limit.h"
|
2019-03-29 14:02:57 -07:00
|
|
|
#include "core/hle/kernel/scheduler.h"
|
2014-05-09 19:11:18 -07:00
|
|
|
#include "core/hle/kernel/thread.h"
|
2018-08-28 09:30:33 -07:00
|
|
|
#include "core/hle/lock.h"
|
|
|
|
#include "core/hle/result.h"
|
2019-04-06 22:10:44 -07:00
|
|
|
#include "core/memory.h"
|
2014-05-09 19:11:18 -07:00
|
|
|
|
2014-05-20 15:13:25 -07:00
|
|
|
namespace Kernel {
|
2014-05-09 19:11:18 -07:00
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
/**
|
|
|
|
* Callback that will wake up the thread it was scheduled for
|
|
|
|
* @param thread_handle The handle of the thread that's been awoken
|
|
|
|
* @param cycles_late The number of CPU cycles that have passed since the desired wakeup time
|
|
|
|
*/
|
2019-03-24 15:11:32 -07:00
|
|
|
static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_late) {
|
2018-08-28 09:30:33 -07:00
|
|
|
const auto proper_handle = static_cast<Handle>(thread_handle);
|
2018-10-28 14:44:46 -07:00
|
|
|
const auto& system = Core::System::GetInstance();
|
2018-08-28 09:30:33 -07:00
|
|
|
|
|
|
|
// Lock the global kernel mutex when we enter the kernel HLE.
|
2019-04-01 09:29:59 -07:00
|
|
|
std::lock_guard lock{HLE::g_hle_lock};
|
2018-08-28 09:30:33 -07:00
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
std::shared_ptr<Thread> thread =
|
2018-08-28 09:30:33 -07:00
|
|
|
system.Kernel().RetrieveThreadFromWakeupCallbackHandleTable(proper_handle);
|
|
|
|
if (thread == nullptr) {
|
|
|
|
LOG_CRITICAL(Kernel, "Callback fired for invalid thread {:08X}", proper_handle);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool resume = true;
|
|
|
|
|
2019-04-17 04:21:19 -07:00
|
|
|
if (thread->GetStatus() == ThreadStatus::WaitSynch ||
|
2018-10-03 15:47:57 -07:00
|
|
|
thread->GetStatus() == ThreadStatus::WaitHLEEvent) {
|
2018-08-28 09:30:33 -07:00
|
|
|
// Remove the thread from each of its waiting objects' waitlists
|
2018-10-03 15:47:57 -07:00
|
|
|
for (const auto& object : thread->GetWaitObjects()) {
|
2019-11-24 17:15:51 -08:00
|
|
|
object->RemoveWaitingThread(thread);
|
2018-08-28 09:30:33 -07:00
|
|
|
}
|
2018-10-03 15:47:57 -07:00
|
|
|
thread->ClearWaitObjects();
|
2018-08-28 09:30:33 -07:00
|
|
|
|
|
|
|
// Invoke the wakeup callback before clearing the wait objects
|
2018-10-03 15:47:57 -07:00
|
|
|
if (thread->HasWakeupCallback()) {
|
|
|
|
resume = thread->InvokeWakeupCallback(ThreadWakeupReason::Timeout, thread, nullptr, 0);
|
2018-08-28 09:30:33 -07:00
|
|
|
}
|
2019-10-07 15:57:13 -07:00
|
|
|
} else if (thread->GetStatus() == ThreadStatus::WaitMutex ||
|
|
|
|
thread->GetStatus() == ThreadStatus::WaitCondVar) {
|
2018-10-03 15:47:57 -07:00
|
|
|
thread->SetMutexWaitAddress(0);
|
|
|
|
thread->SetWaitHandle(0);
|
2019-11-14 16:13:18 -08:00
|
|
|
if (thread->GetStatus() == ThreadStatus::WaitCondVar) {
|
|
|
|
thread->GetOwnerProcess()->RemoveConditionVariableThread(thread);
|
2019-11-21 07:03:37 -08:00
|
|
|
thread->SetCondVarWaitAddress(0);
|
2019-11-14 16:13:18 -08:00
|
|
|
}
|
2018-08-28 09:30:33 -07:00
|
|
|
|
2018-10-03 15:47:57 -07:00
|
|
|
auto* const lock_owner = thread->GetLockOwner();
|
2018-08-28 09:30:33 -07:00
|
|
|
// Threads waking up by timeout from WaitProcessWideKey do not perform priority inheritance
|
|
|
|
// and don't have a lock owner unless SignalProcessWideKey was called first and the thread
|
|
|
|
// wasn't awakened due to the mutex already being acquired.
|
2018-10-03 15:47:57 -07:00
|
|
|
if (lock_owner != nullptr) {
|
2018-08-28 09:30:33 -07:00
|
|
|
lock_owner->RemoveMutexWaiter(thread);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-11 07:55:38 -08:00
|
|
|
if (thread->GetStatus() == ThreadStatus::WaitArb) {
|
|
|
|
auto& address_arbiter = thread->GetOwnerProcess()->GetAddressArbiter();
|
|
|
|
address_arbiter.HandleWakeupThread(thread);
|
2018-08-28 09:30:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (resume) {
|
2019-10-07 15:57:13 -07:00
|
|
|
if (thread->GetStatus() == ThreadStatus::WaitCondVar ||
|
|
|
|
thread->GetStatus() == ThreadStatus::WaitArb) {
|
|
|
|
thread->SetWaitSynchronizationResult(RESULT_TIMEOUT);
|
|
|
|
}
|
2018-08-28 09:30:33 -07:00
|
|
|
thread->ResumeFromWait();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
struct KernelCore::Impl {
|
2019-06-19 06:11:18 -07:00
|
|
|
explicit Impl(Core::System& system) : system{system}, global_scheduler{system} {}
|
2019-03-05 09:28:10 -08:00
|
|
|
|
|
|
|
void Initialize(KernelCore& kernel) {
|
2018-08-28 09:30:33 -07:00
|
|
|
Shutdown();
|
2015-04-27 19:12:35 -07:00
|
|
|
|
2020-01-30 15:19:21 -08:00
|
|
|
InitializePhysicalCores();
|
2018-11-19 09:54:06 -08:00
|
|
|
InitializeSystemResourceLimit(kernel);
|
2019-03-05 09:28:10 -08:00
|
|
|
InitializeThreads();
|
2019-09-10 08:04:40 -07:00
|
|
|
InitializePreemption();
|
2018-08-28 09:30:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void Shutdown() {
|
|
|
|
next_object_id = 0;
|
2019-06-09 21:28:33 -07:00
|
|
|
next_kernel_process_id = Process::InitialKIPIDMin;
|
|
|
|
next_user_process_id = Process::ProcessIDMin;
|
2018-08-28 09:30:33 -07:00
|
|
|
next_thread_id = 1;
|
|
|
|
|
|
|
|
process_list.clear();
|
2018-10-09 21:42:10 -07:00
|
|
|
current_process = nullptr;
|
2018-08-28 09:30:33 -07:00
|
|
|
|
2018-11-19 09:54:06 -08:00
|
|
|
system_resource_limit = nullptr;
|
2018-08-28 09:30:33 -07:00
|
|
|
|
|
|
|
thread_wakeup_callback_handle_table.Clear();
|
|
|
|
thread_wakeup_event_type = nullptr;
|
2019-09-10 08:04:40 -07:00
|
|
|
preemption_event = nullptr;
|
2018-08-28 09:30:33 -07:00
|
|
|
|
2019-10-12 05:21:51 -07:00
|
|
|
global_scheduler.Shutdown();
|
|
|
|
|
2018-09-02 08:58:58 -07:00
|
|
|
named_ports.clear();
|
2020-01-25 14:55:32 -08:00
|
|
|
|
|
|
|
for (auto& core : cores) {
|
|
|
|
core.Shutdown();
|
|
|
|
}
|
|
|
|
cores.clear();
|
|
|
|
|
2020-01-30 15:19:21 -08:00
|
|
|
exclusive_monitor.reset();
|
2020-01-25 14:55:32 -08:00
|
|
|
}
|
|
|
|
|
2020-01-30 15:19:21 -08:00
|
|
|
void InitializePhysicalCores() {
|
2020-01-26 12:14:18 -08:00
|
|
|
exclusive_monitor =
|
|
|
|
Core::MakeExclusiveMonitor(system.Memory(), global_scheduler.CpuCoresCount());
|
2020-01-25 14:55:32 -08:00
|
|
|
for (std::size_t i = 0; i < global_scheduler.CpuCoresCount(); i++) {
|
2020-01-30 15:19:21 -08:00
|
|
|
cores.emplace_back(system, i, *exclusive_monitor);
|
2020-01-25 14:55:32 -08:00
|
|
|
}
|
2018-08-28 09:30:33 -07:00
|
|
|
}
|
|
|
|
|
2018-11-19 09:54:06 -08:00
|
|
|
// Creates the default system resource limit
|
|
|
|
void InitializeSystemResourceLimit(KernelCore& kernel) {
|
2019-04-01 13:46:00 -07:00
|
|
|
system_resource_limit = ResourceLimit::Create(kernel);
|
2018-11-19 09:54:06 -08:00
|
|
|
|
|
|
|
// If setting the default system values fails, then something seriously wrong has occurred.
|
|
|
|
ASSERT(system_resource_limit->SetLimitValue(ResourceType::PhysicalMemory, 0x200000000)
|
|
|
|
.IsSuccess());
|
|
|
|
ASSERT(system_resource_limit->SetLimitValue(ResourceType::Threads, 800).IsSuccess());
|
|
|
|
ASSERT(system_resource_limit->SetLimitValue(ResourceType::Events, 700).IsSuccess());
|
|
|
|
ASSERT(system_resource_limit->SetLimitValue(ResourceType::TransferMemory, 200).IsSuccess());
|
|
|
|
ASSERT(system_resource_limit->SetLimitValue(ResourceType::Sessions, 900).IsSuccess());
|
2018-08-28 09:30:33 -07:00
|
|
|
}
|
|
|
|
|
2019-03-05 09:28:10 -08:00
|
|
|
void InitializeThreads() {
|
2018-08-28 09:30:33 -07:00
|
|
|
thread_wakeup_event_type =
|
2019-11-26 18:48:56 -08:00
|
|
|
Core::Timing::CreateEvent("ThreadWakeupCallback", ThreadWakeupCallback);
|
2018-08-28 09:30:33 -07:00
|
|
|
}
|
|
|
|
|
2019-09-10 08:04:40 -07:00
|
|
|
void InitializePreemption() {
|
2019-11-26 18:48:56 -08:00
|
|
|
preemption_event =
|
|
|
|
Core::Timing::CreateEvent("PreemptionCallback", [this](u64 userdata, s64 cycles_late) {
|
2019-09-10 08:04:40 -07:00
|
|
|
global_scheduler.PreemptThreads();
|
|
|
|
s64 time_interval = Core::Timing::msToCycles(std::chrono::milliseconds(10));
|
|
|
|
system.CoreTiming().ScheduleEvent(time_interval, preemption_event);
|
|
|
|
});
|
|
|
|
|
|
|
|
s64 time_interval = Core::Timing::msToCycles(std::chrono::milliseconds(10));
|
|
|
|
system.CoreTiming().ScheduleEvent(time_interval, preemption_event);
|
|
|
|
}
|
|
|
|
|
2019-11-26 15:34:30 -08:00
|
|
|
void MakeCurrentProcess(Process* process) {
|
|
|
|
current_process = process;
|
|
|
|
|
|
|
|
if (process == nullptr) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
system.Memory().SetCurrentPageTable(*process);
|
|
|
|
}
|
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
std::atomic<u32> next_object_id{0};
|
2019-06-09 21:28:33 -07:00
|
|
|
std::atomic<u64> next_kernel_process_id{Process::InitialKIPIDMin};
|
|
|
|
std::atomic<u64> next_user_process_id{Process::ProcessIDMin};
|
2018-12-18 19:37:01 -08:00
|
|
|
std::atomic<u64> next_thread_id{1};
|
2018-08-28 09:30:33 -07:00
|
|
|
|
|
|
|
// Lists all processes that exist in the current session.
|
2019-11-24 17:15:51 -08:00
|
|
|
std::vector<std::shared_ptr<Process>> process_list;
|
2018-10-09 21:42:10 -07:00
|
|
|
Process* current_process = nullptr;
|
2019-03-29 14:02:57 -07:00
|
|
|
Kernel::GlobalScheduler global_scheduler;
|
2018-08-28 09:30:33 -07:00
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
std::shared_ptr<ResourceLimit> system_resource_limit;
|
2018-08-28 09:30:33 -07:00
|
|
|
|
2019-11-26 18:48:56 -08:00
|
|
|
std::shared_ptr<Core::Timing::EventType> thread_wakeup_event_type;
|
|
|
|
std::shared_ptr<Core::Timing::EventType> preemption_event;
|
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
// TODO(yuriks): This can be removed if Thread objects are explicitly pooled in the future,
|
|
|
|
// allowing us to simply use a pool index or similar.
|
|
|
|
Kernel::HandleTable thread_wakeup_callback_handle_table;
|
2018-09-02 08:58:58 -07:00
|
|
|
|
|
|
|
/// Map of named ports managed by the kernel, which can be retrieved using
|
|
|
|
/// the ConnectToPort SVC.
|
|
|
|
NamedPortTable named_ports;
|
2019-03-05 09:28:10 -08:00
|
|
|
|
2020-01-25 14:55:32 -08:00
|
|
|
std::unique_ptr<Core::ExclusiveMonitor> exclusive_monitor;
|
|
|
|
std::vector<Kernel::PhysicalCore> cores;
|
|
|
|
|
2019-03-05 09:28:10 -08:00
|
|
|
// System context
|
|
|
|
Core::System& system;
|
2018-08-28 09:30:33 -07:00
|
|
|
};
|
|
|
|
|
2019-03-05 09:28:10 -08:00
|
|
|
KernelCore::KernelCore(Core::System& system) : impl{std::make_unique<Impl>(system)} {}
|
2018-08-28 09:30:33 -07:00
|
|
|
KernelCore::~KernelCore() {
|
|
|
|
Shutdown();
|
|
|
|
}
|
|
|
|
|
2019-03-05 09:28:10 -08:00
|
|
|
void KernelCore::Initialize() {
|
|
|
|
impl->Initialize(*this);
|
2018-08-28 09:30:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void KernelCore::Shutdown() {
|
|
|
|
impl->Shutdown();
|
|
|
|
}
|
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
std::shared_ptr<ResourceLimit> KernelCore::GetSystemResourceLimit() const {
|
2018-11-19 09:54:06 -08:00
|
|
|
return impl->system_resource_limit;
|
2018-08-28 09:30:33 -07:00
|
|
|
}
|
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
std::shared_ptr<Thread> KernelCore::RetrieveThreadFromWakeupCallbackHandleTable(
|
|
|
|
Handle handle) const {
|
2018-08-28 09:30:33 -07:00
|
|
|
return impl->thread_wakeup_callback_handle_table.Get<Thread>(handle);
|
|
|
|
}
|
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
void KernelCore::AppendNewProcess(std::shared_ptr<Process> process) {
|
2018-08-28 09:30:33 -07:00
|
|
|
impl->process_list.push_back(std::move(process));
|
|
|
|
}
|
|
|
|
|
2018-10-09 21:42:10 -07:00
|
|
|
void KernelCore::MakeCurrentProcess(Process* process) {
|
2019-11-26 15:34:30 -08:00
|
|
|
impl->MakeCurrentProcess(process);
|
2018-09-06 17:34:51 -07:00
|
|
|
}
|
|
|
|
|
2018-10-09 21:42:10 -07:00
|
|
|
Process* KernelCore::CurrentProcess() {
|
2018-09-06 17:34:51 -07:00
|
|
|
return impl->current_process;
|
|
|
|
}
|
|
|
|
|
2018-10-09 21:42:10 -07:00
|
|
|
const Process* KernelCore::CurrentProcess() const {
|
2018-09-06 17:34:51 -07:00
|
|
|
return impl->current_process;
|
|
|
|
}
|
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
const std::vector<std::shared_ptr<Process>>& KernelCore::GetProcessList() const {
|
2019-03-20 12:03:52 -07:00
|
|
|
return impl->process_list;
|
|
|
|
}
|
|
|
|
|
2019-03-29 14:02:57 -07:00
|
|
|
Kernel::GlobalScheduler& KernelCore::GlobalScheduler() {
|
|
|
|
return impl->global_scheduler;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Kernel::GlobalScheduler& KernelCore::GlobalScheduler() const {
|
|
|
|
return impl->global_scheduler;
|
|
|
|
}
|
|
|
|
|
2020-01-25 14:55:32 -08:00
|
|
|
Kernel::PhysicalCore& KernelCore::PhysicalCore(std::size_t id) {
|
|
|
|
return impl->cores[id];
|
|
|
|
}
|
|
|
|
|
|
|
|
const Kernel::PhysicalCore& KernelCore::PhysicalCore(std::size_t id) const {
|
|
|
|
return impl->cores[id];
|
|
|
|
}
|
|
|
|
|
|
|
|
Core::ExclusiveMonitor& KernelCore::GetExclusiveMonitor() {
|
|
|
|
return *impl->exclusive_monitor;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Core::ExclusiveMonitor& KernelCore::GetExclusiveMonitor() const {
|
|
|
|
return *impl->exclusive_monitor;
|
|
|
|
}
|
|
|
|
|
|
|
|
void KernelCore::InvalidateAllInstructionCaches() {
|
|
|
|
for (std::size_t i = 0; i < impl->global_scheduler.CpuCoresCount(); i++) {
|
|
|
|
PhysicalCore(i).ArmInterface().ClearInstructionCache();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void KernelCore::PrepareReschedule(std::size_t id) {
|
2020-01-26 12:14:18 -08:00
|
|
|
if (id < impl->global_scheduler.CpuCoresCount()) {
|
2020-01-25 14:55:32 -08:00
|
|
|
impl->cores[id].Stop();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
void KernelCore::AddNamedPort(std::string name, std::shared_ptr<ClientPort> port) {
|
2018-09-02 08:58:58 -07:00
|
|
|
impl->named_ports.emplace(std::move(name), std::move(port));
|
|
|
|
}
|
|
|
|
|
|
|
|
KernelCore::NamedPortTable::iterator KernelCore::FindNamedPort(const std::string& name) {
|
|
|
|
return impl->named_ports.find(name);
|
|
|
|
}
|
|
|
|
|
|
|
|
KernelCore::NamedPortTable::const_iterator KernelCore::FindNamedPort(
|
|
|
|
const std::string& name) const {
|
|
|
|
return impl->named_ports.find(name);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool KernelCore::IsValidNamedPort(NamedPortTable::const_iterator port) const {
|
|
|
|
return port != impl->named_ports.cend();
|
|
|
|
}
|
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
u32 KernelCore::CreateNewObjectID() {
|
|
|
|
return impl->next_object_id++;
|
|
|
|
}
|
|
|
|
|
2018-12-18 19:37:01 -08:00
|
|
|
u64 KernelCore::CreateNewThreadID() {
|
2018-08-28 09:30:33 -07:00
|
|
|
return impl->next_thread_id++;
|
2014-05-20 15:13:25 -07:00
|
|
|
}
|
|
|
|
|
2019-06-09 21:28:33 -07:00
|
|
|
u64 KernelCore::CreateNewKernelProcessID() {
|
|
|
|
return impl->next_kernel_process_id++;
|
|
|
|
}
|
|
|
|
|
|
|
|
u64 KernelCore::CreateNewUserProcessID() {
|
|
|
|
return impl->next_user_process_id++;
|
2018-08-28 09:30:33 -07:00
|
|
|
}
|
2015-08-05 17:26:52 -07:00
|
|
|
|
2019-11-26 18:48:56 -08:00
|
|
|
const std::shared_ptr<Core::Timing::EventType>& KernelCore::ThreadWakeupCallbackEventType() const {
|
2018-08-28 09:30:33 -07:00
|
|
|
return impl->thread_wakeup_event_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
Kernel::HandleTable& KernelCore::ThreadWakeupCallbackHandleTable() {
|
|
|
|
return impl->thread_wakeup_callback_handle_table;
|
|
|
|
}
|
2015-08-05 17:26:52 -07:00
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
const Kernel::HandleTable& KernelCore::ThreadWakeupCallbackHandleTable() const {
|
|
|
|
return impl->thread_wakeup_callback_handle_table;
|
2014-05-13 18:57:12 -07:00
|
|
|
}
|
2014-05-22 16:06:12 -07:00
|
|
|
|
2018-01-01 10:25:37 -08:00
|
|
|
} // namespace Kernel
|