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-02-22 06:27:40 -08:00
|
|
|
#include <bitset>
|
2020-01-26 06:28:23 -08:00
|
|
|
#include <functional>
|
2018-08-28 09:30:33 -07:00
|
|
|
#include <memory>
|
|
|
|
#include <mutex>
|
2020-02-14 05:30:53 -08:00
|
|
|
#include <thread>
|
|
|
|
#include <unordered_map>
|
2018-08-28 09:30:33 -07:00
|
|
|
#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"
|
2020-02-22 06:27:40 -08:00
|
|
|
#include "core/hardware_properties.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"
|
2020-02-11 13:36:39 -08:00
|
|
|
#include "core/hle/kernel/synchronization.h"
|
2014-05-09 19:11:18 -07:00
|
|
|
#include "core/hle/kernel/thread.h"
|
2020-02-14 06:56:27 -08:00
|
|
|
#include "core/hle/kernel/time_manager.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 =
|
2020-02-14 05:30:53 -08:00
|
|
|
system.Kernel().RetrieveThreadFromGlobalHandleTable(proper_handle);
|
2018-08-28 09:30:33 -07:00
|
|
|
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
|
2020-02-11 06:46:25 -08:00
|
|
|
for (const auto& object : thread->GetSynchronizationObjects()) {
|
2019-11-24 17:15:51 -08:00
|
|
|
object->RemoveWaitingThread(thread);
|
2018-08-28 09:30:33 -07:00
|
|
|
}
|
2020-02-11 06:46:25 -08:00
|
|
|
thread->ClearSynchronizationObjects();
|
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 {
|
2020-02-13 18:04:10 -08:00
|
|
|
explicit Impl(Core::System& system, KernelCore& kernel)
|
2020-04-15 10:28:28 -07:00
|
|
|
: global_scheduler{kernel}, synchronization{system}, time_manager{system}, system{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
|
|
|
|
2020-02-14 05:30:53 -08:00
|
|
|
global_handle_table.Clear();
|
2018-08-28 09:30:33 -07:00
|
|
|
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 =
|
2020-02-14 05:30:53 -08:00
|
|
|
Core::MakeExclusiveMonitor(system.Memory(), Core::Hardware::NUM_CPU_CORES);
|
|
|
|
for (std::size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; 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;
|
|
|
|
}
|
|
|
|
|
2020-03-01 20:46:10 -08:00
|
|
|
for (auto& core : cores) {
|
|
|
|
core.SetIs64Bit(process->Is64BitProcess());
|
|
|
|
}
|
|
|
|
|
2019-11-26 15:34:30 -08:00
|
|
|
system.Memory().SetCurrentPageTable(*process);
|
|
|
|
}
|
|
|
|
|
2020-02-14 05:30:53 -08:00
|
|
|
void RegisterCoreThread(std::size_t core_id) {
|
2020-02-22 06:27:40 -08:00
|
|
|
std::unique_lock lock{register_thread_mutex};
|
2020-02-14 05:30:53 -08:00
|
|
|
const std::thread::id this_id = std::this_thread::get_id();
|
|
|
|
const auto it = host_thread_ids.find(this_id);
|
|
|
|
ASSERT(core_id < Core::Hardware::NUM_CPU_CORES);
|
|
|
|
ASSERT(it == host_thread_ids.end());
|
|
|
|
ASSERT(!registered_core_threads[core_id]);
|
|
|
|
host_thread_ids[this_id] = static_cast<u32>(core_id);
|
|
|
|
registered_core_threads.set(core_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
void RegisterHostThread() {
|
2020-02-22 06:27:40 -08:00
|
|
|
std::unique_lock lock{register_thread_mutex};
|
2020-02-14 05:30:53 -08:00
|
|
|
const std::thread::id this_id = std::this_thread::get_id();
|
|
|
|
const auto it = host_thread_ids.find(this_id);
|
|
|
|
ASSERT(it == host_thread_ids.end());
|
|
|
|
host_thread_ids[this_id] = registered_thread_ids++;
|
|
|
|
}
|
|
|
|
|
2020-02-22 06:27:40 -08:00
|
|
|
u32 GetCurrentHostThreadID() const {
|
2020-02-14 05:30:53 -08:00
|
|
|
const std::thread::id this_id = std::this_thread::get_id();
|
|
|
|
const auto it = host_thread_ids.find(this_id);
|
|
|
|
if (it == host_thread_ids.end()) {
|
|
|
|
return Core::INVALID_HOST_THREAD_ID;
|
|
|
|
}
|
|
|
|
return it->second;
|
|
|
|
}
|
|
|
|
|
2020-02-22 06:27:40 -08:00
|
|
|
Core::EmuThreadHandle GetCurrentEmuThreadID() const {
|
2020-02-14 05:30:53 -08:00
|
|
|
Core::EmuThreadHandle result = Core::EmuThreadHandle::InvalidHandle();
|
2020-02-22 06:27:40 -08:00
|
|
|
result.host_handle = GetCurrentHostThreadID();
|
2020-02-14 05:30:53 -08:00
|
|
|
if (result.host_handle >= Core::Hardware::NUM_CPU_CORES) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
const Kernel::Scheduler& sched = cores[result.host_handle].Scheduler();
|
|
|
|
const Kernel::Thread* current = sched.GetCurrentThread();
|
|
|
|
if (current != nullptr) {
|
|
|
|
result.guest_handle = current->GetGlobalHandle();
|
|
|
|
} else {
|
|
|
|
result.guest_handle = InvalidHandle;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
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;
|
2020-02-11 13:36:39 -08:00
|
|
|
Kernel::Synchronization synchronization;
|
2020-02-14 06:56:27 -08:00
|
|
|
Kernel::TimeManager time_manager;
|
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;
|
|
|
|
|
2020-02-22 06:27:40 -08:00
|
|
|
// This is the kernel's handle table or supervisor handle table which
|
|
|
|
// stores all the objects in place.
|
2020-02-14 05:30:53 -08:00
|
|
|
Kernel::HandleTable global_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;
|
|
|
|
|
2020-02-22 06:27:40 -08:00
|
|
|
// 0-3 IDs represent core threads, >3 represent others
|
2020-02-14 05:30:53 -08:00
|
|
|
std::unordered_map<std::thread::id, u32> host_thread_ids;
|
|
|
|
u32 registered_thread_ids{Core::Hardware::NUM_CPU_CORES};
|
2020-02-22 06:27:40 -08:00
|
|
|
std::bitset<Core::Hardware::NUM_CPU_CORES> registered_core_threads;
|
|
|
|
std::mutex register_thread_mutex;
|
2020-02-14 05:30:53 -08:00
|
|
|
|
2019-03-05 09:28:10 -08:00
|
|
|
// System context
|
|
|
|
Core::System& system;
|
2018-08-28 09:30:33 -07:00
|
|
|
};
|
|
|
|
|
2020-02-13 18:04:10 -08:00
|
|
|
KernelCore::KernelCore(Core::System& system) : impl{std::make_unique<Impl>(system, *this)} {}
|
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
|
|
|
}
|
|
|
|
|
2020-02-14 05:30:53 -08:00
|
|
|
std::shared_ptr<Thread> KernelCore::RetrieveThreadFromGlobalHandleTable(Handle handle) const {
|
|
|
|
return impl->global_handle_table.Get<Thread>(handle);
|
2018-08-28 09:30:33 -07:00
|
|
|
}
|
|
|
|
|
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-02-13 18:04:10 -08:00
|
|
|
Kernel::Scheduler& KernelCore::Scheduler(std::size_t id) {
|
|
|
|
return impl->cores[id].Scheduler();
|
|
|
|
}
|
|
|
|
|
|
|
|
const Kernel::Scheduler& KernelCore::Scheduler(std::size_t id) const {
|
|
|
|
return impl->cores[id].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];
|
|
|
|
}
|
|
|
|
|
2020-02-11 13:36:39 -08:00
|
|
|
Kernel::Synchronization& KernelCore::Synchronization() {
|
|
|
|
return impl->synchronization;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Kernel::Synchronization& KernelCore::Synchronization() const {
|
|
|
|
return impl->synchronization;
|
|
|
|
}
|
|
|
|
|
2020-02-14 06:56:27 -08:00
|
|
|
Kernel::TimeManager& KernelCore::TimeManager() {
|
|
|
|
return impl->time_manager;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Kernel::TimeManager& KernelCore::TimeManager() const {
|
|
|
|
return impl->time_manager;
|
|
|
|
}
|
|
|
|
|
2020-01-25 14:55:32 -08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-02-14 05:30:53 -08:00
|
|
|
Kernel::HandleTable& KernelCore::GlobalHandleTable() {
|
|
|
|
return impl->global_handle_table;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Kernel::HandleTable& KernelCore::GlobalHandleTable() const {
|
|
|
|
return impl->global_handle_table;
|
|
|
|
}
|
|
|
|
|
|
|
|
void KernelCore::RegisterCoreThread(std::size_t core_id) {
|
|
|
|
impl->RegisterCoreThread(core_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
void KernelCore::RegisterHostThread() {
|
|
|
|
impl->RegisterHostThread();
|
|
|
|
}
|
|
|
|
|
2020-02-22 06:27:40 -08:00
|
|
|
u32 KernelCore::GetCurrentHostThreadID() const {
|
|
|
|
return impl->GetCurrentHostThreadID();
|
2018-08-28 09:30:33 -07:00
|
|
|
}
|
2015-08-05 17:26:52 -07:00
|
|
|
|
2020-02-22 06:27:40 -08:00
|
|
|
Core::EmuThreadHandle KernelCore::GetCurrentEmuThreadID() const {
|
|
|
|
return impl->GetCurrentEmuThreadID();
|
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
|