pineapple-src/src/core/hle/kernel/kernel.h

415 lines
15 KiB
C
Raw Normal View History

2021-04-04 23:30:07 +00:00
// Copyright 2021 yuzu Emulator Project
2020-12-28 15:15:37 +00:00
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#pragma once
#include <array>
2021-09-12 18:41:46 +00:00
#include <functional>
2020-12-28 15:15:37 +00:00
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include "core/arm/cpu_interrupt_handler.h"
#include "core/hardware_properties.h"
2021-05-06 02:45:54 +00:00
#include "core/hle/kernel/k_auto_object.h"
#include "core/hle/kernel/k_slab_heap.h"
#include "core/hle/kernel/svc_common.h"
2020-12-28 15:15:37 +00:00
namespace Core {
class CPUInterruptHandler;
class ExclusiveMonitor;
class System;
} // namespace Core
namespace Core::Timing {
class CoreTiming;
struct EventType;
} // namespace Core::Timing
2021-05-11 00:22:43 +00:00
namespace Service::SM {
class ServiceManager;
}
2020-12-28 15:15:37 +00:00
namespace Kernel {
2021-05-06 02:45:54 +00:00
class KClientPort;
2020-12-28 15:15:37 +00:00
class GlobalSchedulerContext;
2021-05-06 02:45:54 +00:00
class KAutoObjectWithListContainer;
class KClientSession;
class KEvent;
class KHandleTable;
class KLinkedListNode;
2022-02-27 02:37:54 +00:00
class KMemoryLayout;
2021-02-19 01:26:25 +00:00
class KMemoryManager;
2022-03-12 10:35:05 +00:00
class KPageBuffer;
2021-05-06 02:45:54 +00:00
class KPort;
class KProcess;
2021-01-31 06:17:28 +00:00
class KResourceLimit;
2020-12-28 15:15:37 +00:00
class KScheduler;
2021-07-03 09:00:06 +00:00
class KServerSession;
2021-05-06 02:45:54 +00:00
class KSession;
2021-02-19 01:26:25 +00:00
class KSharedMemory;
2021-09-29 17:55:52 +00:00
class KSharedMemoryInfo;
2021-02-19 01:26:25 +00:00
class KThread;
2022-03-12 10:35:05 +00:00
class KThreadLocalPage;
2021-05-06 02:45:54 +00:00
class KTransferMemory;
2022-01-15 02:23:49 +00:00
class KWorkerTaskManager;
2021-05-06 02:45:54 +00:00
class KWritableEvent;
2021-12-09 20:14:12 +00:00
class KCodeMemory;
2021-02-19 01:26:25 +00:00
class PhysicalCore;
2020-12-30 01:38:14 +00:00
class ServiceThread;
2020-12-28 15:15:37 +00:00
class Synchronization;
class TimeManager;
2021-05-11 00:22:43 +00:00
using ServiceInterfaceFactory =
std::function<KClientPort&(Service::SM::ServiceManager&, Core::System&)>;
2021-05-06 02:45:54 +00:00
namespace Init {
struct KSlabResourceCounts;
}
2021-02-19 01:26:25 +00:00
template <typename T>
class KSlabHeap;
2021-01-22 00:15:25 +00:00
using EmuThreadHandle = uintptr_t;
constexpr EmuThreadHandle EmuThreadHandleInvalid{};
constexpr EmuThreadHandle EmuThreadHandleReserved{1ULL << 63};
2020-12-28 15:15:37 +00:00
/// Represents a single instance of the kernel.
class KernelCore {
private:
2021-05-06 02:45:54 +00:00
using NamedPortTable = std::unordered_map<std::string, KClientPort*>;
2020-12-28 15:15:37 +00:00
public:
/// Constructs an instance of the kernel using the given System
/// instance as a context for any necessary system-related state,
/// such as threads, CPU core state, etc.
///
/// @post After execution of the constructor, the provided System
/// object *must* outlive the kernel instance itself.
///
explicit KernelCore(Core::System& system);
~KernelCore();
KernelCore(const KernelCore&) = delete;
KernelCore& operator=(const KernelCore&) = delete;
KernelCore(KernelCore&&) = delete;
KernelCore& operator=(KernelCore&&) = delete;
/// Sets if emulation is multicore or single core, must be set before Initialize
void SetMulticore(bool is_multicore);
/// Resets the kernel to a clean slate for use.
void Initialize();
/// Initializes the CPU cores.
void InitializeCores();
/// Clears all resources in use by the kernel instance.
void Shutdown();
/// Retrieves a shared pointer to the system resource limit instance.
2021-05-06 02:45:54 +00:00
const KResourceLimit* GetSystemResourceLimit() const;
/// Retrieves a shared pointer to the system resource limit instance.
KResourceLimit* GetSystemResourceLimit();
2020-12-28 15:15:37 +00:00
/// Retrieves a shared pointer to a Thread instance within the thread wakeup handle table.
2021-05-06 02:45:54 +00:00
KScopedAutoObject<KThread> RetrieveThreadFromGlobalHandleTable(Handle handle) const;
2020-12-28 15:15:37 +00:00
/// Adds the given shared pointer to an internal list of active processes.
2021-05-06 02:45:54 +00:00
void AppendNewProcess(KProcess* process);
2020-12-28 15:15:37 +00:00
/// Makes the given process the new current process.
2021-05-06 02:45:54 +00:00
void MakeCurrentProcess(KProcess* process);
2020-12-28 15:15:37 +00:00
/// Retrieves a pointer to the current process.
2021-05-06 02:45:54 +00:00
KProcess* CurrentProcess();
2020-12-28 15:15:37 +00:00
/// Retrieves a const pointer to the current process.
2021-05-06 02:45:54 +00:00
const KProcess* CurrentProcess() const;
2020-12-28 15:15:37 +00:00
/// Retrieves the list of processes.
2021-05-06 02:45:54 +00:00
const std::vector<KProcess*>& GetProcessList() const;
2020-12-28 15:15:37 +00:00
/// Gets the sole instance of the global scheduler
Kernel::GlobalSchedulerContext& GlobalSchedulerContext();
/// Gets the sole instance of the global scheduler
const Kernel::GlobalSchedulerContext& GlobalSchedulerContext() const;
/// Gets the sole instance of the Scheduler assoviated with cpu core 'id'
Kernel::KScheduler& Scheduler(std::size_t id);
/// Gets the sole instance of the Scheduler assoviated with cpu core 'id'
const Kernel::KScheduler& Scheduler(std::size_t id) const;
/// Gets the an instance of the respective physical CPU core.
Kernel::PhysicalCore& PhysicalCore(std::size_t id);
/// Gets the an instance of the respective physical CPU core.
const Kernel::PhysicalCore& PhysicalCore(std::size_t id) const;
2021-12-07 11:04:29 +00:00
/// Gets the current physical core index for the running host thread.
std::size_t CurrentPhysicalCoreIndex() const;
2020-12-28 15:15:37 +00:00
/// Gets the sole instance of the Scheduler at the current running core.
Kernel::KScheduler* CurrentScheduler();
/// Gets the an instance of the current physical CPU core.
Kernel::PhysicalCore& CurrentPhysicalCore();
/// Gets the an instance of the current physical CPU core.
const Kernel::PhysicalCore& CurrentPhysicalCore() const;
/// Gets the an instance of the TimeManager Interface.
Kernel::TimeManager& TimeManager();
/// Gets the an instance of the TimeManager Interface.
const Kernel::TimeManager& TimeManager() const;
/// Stops execution of 'id' core, in order to reschedule a new thread.
void PrepareReschedule(std::size_t id);
Core::ExclusiveMonitor& GetExclusiveMonitor();
const Core::ExclusiveMonitor& GetExclusiveMonitor() const;
2021-05-06 02:45:54 +00:00
KAutoObjectWithListContainer& ObjectListContainer();
const KAutoObjectWithListContainer& ObjectListContainer() const;
2020-12-28 15:15:37 +00:00
std::array<Core::CPUInterruptHandler, Core::Hardware::NUM_CPU_CORES>& Interrupts();
const std::array<Core::CPUInterruptHandler, Core::Hardware::NUM_CPU_CORES>& Interrupts() const;
void InvalidateAllInstructionCaches();
void InvalidateCpuInstructionCacheRange(VAddr addr, std::size_t size);
2021-05-11 00:22:43 +00:00
/// Registers a named HLE service, passing a factory used to open a port to that service.
void RegisterNamedService(std::string name, ServiceInterfaceFactory&& factory);
2020-12-28 15:15:37 +00:00
2021-05-11 00:22:43 +00:00
/// Opens a port to a service previously registered with RegisterNamedService.
KClientPort* CreateNamedServicePort(std::string name);
2020-12-28 15:15:37 +00:00
2021-07-03 09:00:06 +00:00
/// Registers all kernel objects with the global emulation state, this is purely for tracking
/// leaks after emulation has been shutdown.
void RegisterKernelObject(KAutoObject* object);
/// Unregisters a kernel object previously registered with RegisterKernelObject when it was
/// destroyed during the current emulation session.
void UnregisterKernelObject(KAutoObject* object);
2021-10-29 17:27:16 +00:00
/// Registers kernel objects with guest in use state, this is purely for close
/// after emulation has been shutdown.
void RegisterInUseObject(KAutoObject* object);
/// Unregisters a kernel object previously registered with RegisterInUseObject when it was
/// destroyed during the current emulation session.
void UnregisterInUseObject(KAutoObject* object);
2020-12-28 15:15:37 +00:00
/// Determines whether or not the given port is a valid named port.
bool IsValidNamedPort(NamedPortTable::const_iterator port) const;
2021-01-22 00:15:25 +00:00
/// Gets the current host_thread/guest_thread pointer.
KThread* GetCurrentEmuThread() const;
2020-12-28 15:15:37 +00:00
/// Gets the current host_thread handle.
u32 GetCurrentHostThreadID() const;
/// Register the current thread as a CPU Core Thread.
void RegisterCoreThread(std::size_t core_id);
/// Register the current thread as a non CPU core thread.
void RegisterHostThread();
/// Gets the virtual memory manager for the kernel.
2021-02-19 01:26:25 +00:00
KMemoryManager& MemoryManager();
2020-12-28 15:15:37 +00:00
/// Gets the virtual memory manager for the kernel.
2021-02-19 01:26:25 +00:00
const KMemoryManager& MemoryManager() const;
2020-12-28 15:15:37 +00:00
/// Gets the shared memory object for HID services.
2021-02-19 01:26:25 +00:00
Kernel::KSharedMemory& GetHidSharedMem();
2020-12-28 15:15:37 +00:00
/// Gets the shared memory object for HID services.
2021-02-19 01:26:25 +00:00
const Kernel::KSharedMemory& GetHidSharedMem() const;
2020-12-28 15:15:37 +00:00
/// Gets the shared memory object for font services.
2021-02-19 01:26:25 +00:00
Kernel::KSharedMemory& GetFontSharedMem();
2020-12-28 15:15:37 +00:00
/// Gets the shared memory object for font services.
2021-02-19 01:26:25 +00:00
const Kernel::KSharedMemory& GetFontSharedMem() const;
2020-12-28 15:15:37 +00:00
/// Gets the shared memory object for IRS services.
2021-02-19 01:26:25 +00:00
Kernel::KSharedMemory& GetIrsSharedMem();
2020-12-28 15:15:37 +00:00
/// Gets the shared memory object for IRS services.
2021-02-19 01:26:25 +00:00
const Kernel::KSharedMemory& GetIrsSharedMem() const;
2020-12-28 15:15:37 +00:00
/// Gets the shared memory object for Time services.
2021-02-19 01:26:25 +00:00
Kernel::KSharedMemory& GetTimeSharedMem();
2020-12-28 15:15:37 +00:00
/// Gets the shared memory object for Time services.
2021-02-19 01:26:25 +00:00
const Kernel::KSharedMemory& GetTimeSharedMem() const;
2020-12-28 15:15:37 +00:00
2022-03-29 20:45:29 +00:00
/// Gets the shared memory object for HIDBus services.
Kernel::KSharedMemory& GetHidBusSharedMem();
/// Gets the shared memory object for HIDBus services.
const Kernel::KSharedMemory& GetHidBusSharedMem() const;
2020-12-28 15:15:37 +00:00
/// Suspend/unsuspend the OS.
void Suspend(bool in_suspention);
/// Exceptional exit the OS.
void ExceptionalExit();
bool IsMulticore() const;
2021-12-07 11:04:29 +00:00
bool IsShuttingDown() const;
2020-12-28 15:15:37 +00:00
void EnterSVCProfile();
void ExitSVCProfile();
2020-12-30 01:38:14 +00:00
/**
2022-03-31 06:37:55 +00:00
* Creates a host thread to execute HLE service requests, which are used to execute service
* routines asynchronously. While these are allocated per ServerSession, these need to be owned
* and managed outside of ServerSession to avoid a circular dependency. In general, most
* services can just use the default service thread, and not need their own host service thread.
* See GetDefaultServiceThread.
2021-05-06 02:45:54 +00:00
* @param name String name for the ServerSession creating this thread, used for debug
* purposes.
2020-12-30 01:38:14 +00:00
* @returns The a weak pointer newly created service thread.
*/
std::weak_ptr<Kernel::ServiceThread> CreateServiceThread(const std::string& name);
2022-03-31 06:37:55 +00:00
/**
* Gets the default host service thread, which executes HLE service requests. Unless service
* requests need to block on the host, the default service thread should be used in favor of
* creating a new service thread.
* @returns The a weak pointer for the default service thread.
*/
2022-04-02 08:29:48 +00:00
std::weak_ptr<Kernel::ServiceThread> GetDefaultServiceThread() const;
2022-03-31 06:37:55 +00:00
2020-12-30 01:38:14 +00:00
/**
* Releases a HLE service thread, instructing KernelCore to free it. This should be called when
* the ServerSession associated with the thread is destroyed.
* @param service_thread Service thread to release.
*/
void ReleaseServiceThread(std::weak_ptr<Kernel::ServiceThread> service_thread);
2021-01-22 00:15:25 +00:00
/// Workaround for single-core mode when preempting threads while idle.
bool IsPhantomModeForSingleCore() const;
void SetIsPhantomModeForSingleCore(bool value);
2021-05-06 02:45:54 +00:00
Core::System& System();
const Core::System& System() const;
/// Gets the slab heap for the specified kernel object type.
template <typename T>
KSlabHeap<T>& SlabHeap() {
if constexpr (std::is_same_v<T, KClientSession>) {
return slab_heap_container->client_session;
} else if constexpr (std::is_same_v<T, KEvent>) {
return slab_heap_container->event;
} else if constexpr (std::is_same_v<T, KLinkedListNode>) {
return slab_heap_container->linked_list_node;
} else if constexpr (std::is_same_v<T, KPort>) {
return slab_heap_container->port;
} else if constexpr (std::is_same_v<T, KProcess>) {
return slab_heap_container->process;
} else if constexpr (std::is_same_v<T, KResourceLimit>) {
return slab_heap_container->resource_limit;
} else if constexpr (std::is_same_v<T, KSession>) {
return slab_heap_container->session;
} else if constexpr (std::is_same_v<T, KSharedMemory>) {
return slab_heap_container->shared_memory;
2021-09-29 17:55:52 +00:00
} else if constexpr (std::is_same_v<T, KSharedMemoryInfo>) {
return slab_heap_container->shared_memory_info;
2021-05-06 02:45:54 +00:00
} else if constexpr (std::is_same_v<T, KThread>) {
return slab_heap_container->thread;
} else if constexpr (std::is_same_v<T, KTransferMemory>) {
return slab_heap_container->transfer_memory;
} else if constexpr (std::is_same_v<T, KWritableEvent>) {
return slab_heap_container->writeable_event;
2021-12-09 20:14:12 +00:00
} else if constexpr (std::is_same_v<T, KCodeMemory>) {
return slab_heap_container->code_memory;
2022-03-12 10:35:05 +00:00
} else if constexpr (std::is_same_v<T, KPageBuffer>) {
return slab_heap_container->page_buffer;
} else if constexpr (std::is_same_v<T, KThreadLocalPage>) {
return slab_heap_container->thread_local_page;
2021-05-06 02:45:54 +00:00
}
}
/// Gets the current slab resource counts.
Init::KSlabResourceCounts& SlabResourceCounts();
/// Gets the current slab resource counts.
const Init::KSlabResourceCounts& SlabResourceCounts() const;
2022-01-15 02:23:49 +00:00
/// Gets the current worker task manager, used for dispatching KThread/KProcess tasks.
KWorkerTaskManager& WorkerTaskManager();
/// Gets the current worker task manager, used for dispatching KThread/KProcess tasks.
const KWorkerTaskManager& WorkerTaskManager() const;
2022-02-27 02:37:54 +00:00
/// Gets the memory layout.
const KMemoryLayout& MemoryLayout() const;
2020-12-28 15:15:37 +00:00
private:
2021-05-06 02:45:54 +00:00
friend class KProcess;
2021-01-22 00:15:25 +00:00
friend class KThread;
2020-12-28 15:15:37 +00:00
/// Creates a new object ID, incrementing the internal object ID counter.
u32 CreateNewObjectID();
/// Creates a new process ID, incrementing the internal process ID counter;
u64 CreateNewKernelProcessID();
/// Creates a new process ID, incrementing the internal process ID counter;
u64 CreateNewUserProcessID();
/// Creates a new thread ID, incrementing the internal thread ID counter.
u64 CreateNewThreadID();
/// Provides a reference to the global handle table.
2021-05-06 02:45:54 +00:00
KHandleTable& GlobalHandleTable();
2020-12-28 15:15:37 +00:00
/// Provides a const reference to the global handle table.
2021-05-06 02:45:54 +00:00
const KHandleTable& GlobalHandleTable() const;
2020-12-28 15:15:37 +00:00
struct Impl;
std::unique_ptr<Impl> impl;
2021-05-06 02:45:54 +00:00
2020-12-28 15:15:37 +00:00
bool exception_exited{};
2021-05-06 02:45:54 +00:00
private:
/// Helper to encapsulate all slab heaps in a single heap allocated container
struct SlabHeapContainer {
KSlabHeap<KClientSession> client_session;
KSlabHeap<KEvent> event;
KSlabHeap<KLinkedListNode> linked_list_node;
KSlabHeap<KPort> port;
KSlabHeap<KProcess> process;
KSlabHeap<KResourceLimit> resource_limit;
KSlabHeap<KSession> session;
KSlabHeap<KSharedMemory> shared_memory;
2021-09-29 17:55:52 +00:00
KSlabHeap<KSharedMemoryInfo> shared_memory_info;
2021-05-06 02:45:54 +00:00
KSlabHeap<KThread> thread;
KSlabHeap<KTransferMemory> transfer_memory;
KSlabHeap<KWritableEvent> writeable_event;
2021-12-09 20:14:12 +00:00
KSlabHeap<KCodeMemory> code_memory;
2022-03-12 10:35:05 +00:00
KSlabHeap<KPageBuffer> page_buffer;
KSlabHeap<KThreadLocalPage> thread_local_page;
2021-05-06 02:45:54 +00:00
};
std::unique_ptr<SlabHeapContainer> slab_heap_container;
2020-12-28 15:15:37 +00:00
};
} // namespace Kernel