chore: make yuzu REUSE compliant
[REUSE] is a specification that aims at making file copyright
information consistent, so that it can be both human and machine
readable. It basically requires that all files have a header containing
copyright and licensing information. When this isn't possible, like
when dealing with binary assets, generated files or embedded third-party
dependencies, it is permitted to insert copyright information in the
`.reuse/dep5` file.
Oh, and it also requires that all the licenses used in the project are
present in the `LICENSES` folder, that's why the diff is so huge.
This can be done automatically with `reuse download --all`.
The `reuse` tool also contains a handy subcommand that analyzes the
project and tells whether or not the project is (still) compliant,
`reuse lint`.
Following REUSE has a few advantages over the current approach:
- Copyright information is easy to access for users / downstream
- Files like `dist/license.md` do not need to exist anymore, as
`.reuse/dep5` is used instead
- `reuse lint` makes it easy to ensure that copyright information of
files like binary assets / images is always accurate and up to date
To add copyright information of files that didn't have it I looked up
who committed what and when, for each file. As yuzu contributors do not
have to sign a CLA or similar I couldn't assume that copyright ownership
was of the "yuzu Emulator Project", so I used the name and/or email of
the commit author instead.
[REUSE]: https://reuse.software
Follow-up to 01cf05bc75b1e47beb08937439f3ed9339e7b254
2022-05-15 03:06:02 +03:00
|
|
|
// SPDX-FileCopyrightText: 2014 Citra Emulator Project
|
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2013-09-06 02:33:46 +04:00
|
|
|
|
2014-04-09 03:15:46 +04:00
|
|
|
#pragma once
|
2013-09-06 02:33:46 +04:00
|
|
|
|
2018-08-31 19:21:34 +03:00
|
|
|
#include <cstddef>
|
2020-11-25 02:16:24 +03:00
|
|
|
#include <functional>
|
2015-12-30 02:03:08 +03:00
|
|
|
#include <memory>
|
2021-10-16 01:20:19 +03:00
|
|
|
#include <mutex>
|
2016-12-16 03:01:48 +03:00
|
|
|
#include <string>
|
2019-11-25 04:15:51 +03:00
|
|
|
#include <vector>
|
2018-08-31 19:21:34 +03:00
|
|
|
|
2014-12-22 09:30:09 +03:00
|
|
|
#include "common/common_types.h"
|
2018-11-28 22:00:44 +03:00
|
|
|
#include "core/file_sys/vfs_types.h"
|
2014-12-22 09:30:09 +03:00
|
|
|
|
2018-08-12 03:20:19 +03:00
|
|
|
namespace Core::Frontend {
|
|
|
|
class EmuWindow;
|
2018-08-31 19:21:34 +03:00
|
|
|
} // namespace Core::Frontend
|
|
|
|
|
|
|
|
namespace FileSys {
|
2018-12-28 08:03:01 +03:00
|
|
|
class ContentProvider;
|
|
|
|
class ContentProviderUnion;
|
|
|
|
enum class ContentProviderUnionSlot;
|
2018-08-31 19:21:34 +03:00
|
|
|
class VfsFilesystem;
|
|
|
|
} // namespace FileSys
|
|
|
|
|
|
|
|
namespace Kernel {
|
2020-12-03 05:08:35 +03:00
|
|
|
class GlobalSchedulerContext;
|
2018-08-31 19:21:34 +03:00
|
|
|
class KernelCore;
|
2020-02-25 20:22:11 +03:00
|
|
|
class PhysicalCore;
|
2021-04-24 08:04:28 +03:00
|
|
|
class KProcess;
|
2020-12-03 05:08:35 +03:00
|
|
|
class KScheduler;
|
2018-08-31 19:21:34 +03:00
|
|
|
} // namespace Kernel
|
|
|
|
|
|
|
|
namespace Loader {
|
|
|
|
class AppLoader;
|
|
|
|
enum class ResultStatus : u16;
|
|
|
|
} // namespace Loader
|
2018-08-12 03:20:19 +03:00
|
|
|
|
2020-03-31 22:10:44 +03:00
|
|
|
namespace Core::Memory {
|
2019-05-31 02:36:18 +03:00
|
|
|
struct CheatEntry;
|
2020-03-31 22:10:44 +03:00
|
|
|
class Memory;
|
|
|
|
} // namespace Core::Memory
|
2019-05-31 02:36:18 +03:00
|
|
|
|
2019-03-12 02:33:49 +03:00
|
|
|
namespace Service {
|
|
|
|
|
|
|
|
namespace AM::Applets {
|
|
|
|
struct AppletFrontendSet;
|
|
|
|
class AppletManager;
|
|
|
|
} // namespace AM::Applets
|
|
|
|
|
2019-06-29 05:46:31 +03:00
|
|
|
namespace APM {
|
|
|
|
class Controller;
|
|
|
|
}
|
|
|
|
|
2019-04-23 15:35:33 +03:00
|
|
|
namespace FileSystem {
|
|
|
|
class FileSystemController;
|
|
|
|
} // namespace FileSystem
|
|
|
|
|
2019-06-25 02:27:35 +03:00
|
|
|
namespace Glue {
|
|
|
|
class ARPManager;
|
|
|
|
}
|
|
|
|
|
2023-02-19 00:26:48 +03:00
|
|
|
class ServerManager;
|
|
|
|
|
2019-03-12 02:33:49 +03:00
|
|
|
namespace SM {
|
2018-04-21 02:29:04 +03:00
|
|
|
class ServiceManager;
|
2019-03-12 02:33:49 +03:00
|
|
|
} // namespace SM
|
|
|
|
|
2020-10-13 04:09:15 +03:00
|
|
|
namespace Time {
|
|
|
|
class TimeManager;
|
|
|
|
} // namespace Time
|
|
|
|
|
2019-03-12 02:33:49 +03:00
|
|
|
} // namespace Service
|
2018-08-31 19:21:34 +03:00
|
|
|
|
|
|
|
namespace Tegra {
|
|
|
|
class DebugContext;
|
|
|
|
class GPU;
|
2022-01-30 12:31:13 +03:00
|
|
|
namespace Host1x {
|
|
|
|
class Host1x;
|
|
|
|
} // namespace Host1x
|
2018-08-31 19:21:34 +03:00
|
|
|
} // namespace Tegra
|
2018-04-21 02:29:04 +03:00
|
|
|
|
2018-08-03 19:55:58 +03:00
|
|
|
namespace VideoCore {
|
|
|
|
class RendererBase;
|
2018-08-31 19:21:34 +03:00
|
|
|
} // namespace VideoCore
|
2018-08-03 19:55:58 +03:00
|
|
|
|
2022-07-17 01:48:45 +03:00
|
|
|
namespace AudioCore {
|
|
|
|
class AudioCore;
|
|
|
|
} // namespace AudioCore
|
|
|
|
|
2019-02-14 20:42:58 +03:00
|
|
|
namespace Core::Timing {
|
|
|
|
class CoreTiming;
|
|
|
|
}
|
|
|
|
|
2021-09-21 03:44:34 +03:00
|
|
|
namespace Core::HID {
|
|
|
|
class HIDCore;
|
|
|
|
}
|
|
|
|
|
2022-07-22 17:31:13 +03:00
|
|
|
namespace Network {
|
|
|
|
class RoomNetwork;
|
|
|
|
}
|
|
|
|
|
2013-09-06 02:33:46 +04:00
|
|
|
namespace Core {
|
|
|
|
|
2018-08-25 04:43:32 +03:00
|
|
|
class ARM_Interface;
|
2020-02-25 05:04:12 +03:00
|
|
|
class CpuManager;
|
2022-05-31 02:35:01 +03:00
|
|
|
class Debugger;
|
2020-04-03 05:00:41 +03:00
|
|
|
class DeviceMemory;
|
2018-08-31 19:21:34 +03:00
|
|
|
class ExclusiveMonitor;
|
2023-06-28 07:28:13 +03:00
|
|
|
class GPUDirtyMemoryManager;
|
2018-08-31 19:21:34 +03:00
|
|
|
class PerfStats;
|
2019-05-18 04:45:56 +03:00
|
|
|
class Reporter;
|
2023-06-28 07:28:13 +03:00
|
|
|
class SpeedLimiter;
|
2018-08-31 19:21:34 +03:00
|
|
|
class TelemetrySession;
|
|
|
|
|
|
|
|
struct PerfStatsResults;
|
2018-08-25 04:43:32 +03:00
|
|
|
|
2018-11-28 22:00:44 +03:00
|
|
|
FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
|
|
|
|
const std::string& path);
|
|
|
|
|
2021-10-15 01:14:40 +03:00
|
|
|
/// Enumeration representing the return values of the System Initialize and Load process.
|
|
|
|
enum class SystemResultStatus : u32 {
|
|
|
|
Success, ///< Succeeded
|
|
|
|
ErrorNotInitialized, ///< Error trying to use core prior to initialization
|
|
|
|
ErrorGetLoader, ///< Error finding the correct application loader
|
|
|
|
ErrorSystemFiles, ///< Error in finding system files
|
|
|
|
ErrorSharedFont, ///< Error in finding shared font
|
|
|
|
ErrorVideoCore, ///< Error in the video core
|
|
|
|
ErrorUnknown, ///< Any other error
|
|
|
|
ErrorLoader, ///< The base for loader errors (too many to repeat)
|
|
|
|
};
|
|
|
|
|
2016-12-16 03:01:48 +03:00
|
|
|
class System {
|
|
|
|
public:
|
2019-10-06 20:02:23 +03:00
|
|
|
using CurrentBuildProcessID = std::array<u8, 0x20>;
|
|
|
|
|
2021-10-14 21:21:15 +03:00
|
|
|
explicit System();
|
|
|
|
|
|
|
|
~System();
|
|
|
|
|
2018-08-16 17:15:00 +03:00
|
|
|
System(const System&) = delete;
|
|
|
|
System& operator=(const System&) = delete;
|
|
|
|
|
|
|
|
System(System&&) = delete;
|
|
|
|
System& operator=(System&&) = delete;
|
|
|
|
|
2022-09-10 11:48:15 +03:00
|
|
|
/**
|
|
|
|
* Initializes the system
|
2023-03-12 06:10:38 +03:00
|
|
|
* This function will initialize core functionality used for system emulation
|
2022-09-10 11:48:15 +03:00
|
|
|
*/
|
|
|
|
void Initialize();
|
|
|
|
|
2016-12-16 03:01:48 +03:00
|
|
|
/**
|
2020-02-25 05:04:12 +03:00
|
|
|
* Run the OS and Application
|
2020-06-28 01:20:06 +03:00
|
|
|
* This function will start emulation and run the relevant devices
|
2020-02-25 05:04:12 +03:00
|
|
|
*/
|
2022-12-17 22:34:03 +03:00
|
|
|
void Run();
|
2020-02-25 05:04:12 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Pause the OS and Application
|
2020-06-28 01:20:06 +03:00
|
|
|
* This function will pause emulation and stop the relevant devices
|
2016-12-16 03:01:48 +03:00
|
|
|
*/
|
2022-12-17 22:34:03 +03:00
|
|
|
void Pause();
|
2020-02-25 05:04:12 +03:00
|
|
|
|
2022-07-17 01:48:45 +03:00
|
|
|
/// Check if the core is currently paused.
|
|
|
|
[[nodiscard]] bool IsPaused() const;
|
|
|
|
|
2018-08-07 05:01:24 +03:00
|
|
|
/**
|
|
|
|
* Invalidate the CPU instruction caches
|
|
|
|
* This function should only be used by GDB Stub to support breakpoints, memory updates and
|
|
|
|
* step/continue commands.
|
|
|
|
*/
|
2018-08-30 17:50:54 +03:00
|
|
|
void InvalidateCpuInstructionCaches();
|
2018-08-07 05:01:24 +03:00
|
|
|
|
2023-03-18 04:26:04 +03:00
|
|
|
void InvalidateCpuInstructionCacheRange(u64 addr, std::size_t size);
|
2020-11-14 10:20:32 +03:00
|
|
|
|
2022-09-10 11:48:15 +03:00
|
|
|
/// Shutdown the main emulated process.
|
|
|
|
void ShutdownMainProcess();
|
2016-12-16 03:01:48 +03:00
|
|
|
|
2022-07-17 01:48:45 +03:00
|
|
|
/// Check if the core is shutting down.
|
|
|
|
[[nodiscard]] bool IsShuttingDown() const;
|
|
|
|
|
|
|
|
/// Set the shutting down state.
|
|
|
|
void SetShuttingDown(bool shutting_down);
|
|
|
|
|
2022-06-10 16:17:12 +03:00
|
|
|
/// Forcibly detach the debugger if it is running.
|
|
|
|
void DetachDebugger();
|
|
|
|
|
2023-02-13 19:21:43 +03:00
|
|
|
std::unique_lock<std::mutex> StallApplication();
|
|
|
|
void UnstallApplication();
|
2021-10-06 00:54:33 +03:00
|
|
|
|
2023-06-08 08:15:51 +03:00
|
|
|
void SetNVDECActive(bool is_nvdec_active);
|
|
|
|
[[nodiscard]] bool GetNVDECActive();
|
|
|
|
|
2022-05-31 02:35:01 +03:00
|
|
|
/**
|
|
|
|
* Initialize the debugger.
|
|
|
|
*/
|
|
|
|
void InitializeDebugger();
|
|
|
|
|
2016-12-16 03:01:48 +03:00
|
|
|
/**
|
|
|
|
* Load an executable application.
|
2018-08-02 03:59:42 +03:00
|
|
|
* @param emu_window Reference to the host-system window used for video output and keyboard
|
|
|
|
* input.
|
2016-12-16 03:01:48 +03:00
|
|
|
* @param filepath String path to the executable application to load on the host file system.
|
2020-11-25 02:16:24 +03:00
|
|
|
* @param program_index Specifies the index within the container of the program to launch.
|
2021-10-15 01:14:40 +03:00
|
|
|
* @returns SystemResultStatus code, indicating if the operation succeeded.
|
2016-12-16 03:01:48 +03:00
|
|
|
*/
|
2021-10-15 01:14:40 +03:00
|
|
|
[[nodiscard]] SystemResultStatus Load(Frontend::EmuWindow& emu_window,
|
|
|
|
const std::string& filepath, u64 program_id = 0,
|
|
|
|
std::size_t program_index = 0);
|
2016-12-16 03:01:48 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Indicates if the emulated system is powered on (all subsystems initialized and able to run an
|
|
|
|
* application).
|
|
|
|
* @returns True if the emulated system is powered on, otherwise false.
|
|
|
|
*/
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] bool IsPoweredOn() const;
|
2016-12-16 03:01:48 +03:00
|
|
|
|
2018-10-29 00:37:31 +03:00
|
|
|
/// Gets a reference to the telemetry session for this emulation session.
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] Core::TelemetrySession& TelemetrySession();
|
2018-10-29 00:37:31 +03:00
|
|
|
|
|
|
|
/// Gets a reference to the telemetry session for this emulation session.
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] const Core::TelemetrySession& TelemetrySession() const;
|
2017-05-02 07:09:15 +03:00
|
|
|
|
2019-04-02 16:22:53 +03:00
|
|
|
/// Prepare the core emulation for a reschedule
|
2019-06-19 16:11:18 +03:00
|
|
|
void PrepareReschedule(u32 core_index);
|
2019-04-02 16:22:53 +03:00
|
|
|
|
2023-06-28 07:28:13 +03:00
|
|
|
/// Provides a reference to the gou dirty memory manager.
|
|
|
|
[[nodiscard]] Core::GPUDirtyMemoryManager& CurrentGPUDirtyMemoryManager();
|
|
|
|
|
|
|
|
/// Provides a constant reference to the current gou dirty memory manager.
|
|
|
|
[[nodiscard]] const Core::GPUDirtyMemoryManager& CurrentGPUDirtyMemoryManager() const;
|
|
|
|
|
|
|
|
void GatherGPUDirtyMemory(std::function<void(VAddr, size_t)>& callback);
|
|
|
|
|
2023-04-30 18:14:06 +03:00
|
|
|
[[nodiscard]] size_t GetCurrentHostThreadID() const;
|
|
|
|
|
2018-05-11 02:34:21 +03:00
|
|
|
/// Gets and resets core performance statistics
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] PerfStatsResults GetAndResetPerfStats();
|
2017-02-20 01:34:47 +03:00
|
|
|
|
2018-05-11 02:34:21 +03:00
|
|
|
/// Gets an ARM interface to the CPU core that is currently running
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] ARM_Interface& CurrentArmInterface();
|
2018-05-03 05:36:51 +03:00
|
|
|
|
2018-10-29 00:37:31 +03:00
|
|
|
/// Gets an ARM interface to the CPU core that is currently running
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] const ARM_Interface& CurrentArmInterface() const;
|
2018-10-29 00:37:31 +03:00
|
|
|
|
2020-02-25 20:22:11 +03:00
|
|
|
/// Gets the physical core for the CPU core that is currently running
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] Kernel::PhysicalCore& CurrentPhysicalCore();
|
2020-02-25 20:22:11 +03:00
|
|
|
|
|
|
|
/// Gets the physical core for the CPU core that is currently running
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] const Kernel::PhysicalCore& CurrentPhysicalCore() const;
|
2020-02-25 20:22:11 +03:00
|
|
|
|
2018-10-29 00:37:31 +03:00
|
|
|
/// Gets a reference to an ARM interface for the CPU core with the specified index
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] ARM_Interface& ArmInterface(std::size_t core_index);
|
2016-12-16 03:01:48 +03:00
|
|
|
|
2018-10-29 00:37:31 +03:00
|
|
|
/// Gets a const reference to an ARM interface from the CPU core with the specified index
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] const ARM_Interface& ArmInterface(std::size_t core_index) const;
|
2018-10-29 00:37:31 +03:00
|
|
|
|
2020-11-18 10:06:42 +03:00
|
|
|
/// Gets a reference to the underlying CPU manager.
|
|
|
|
[[nodiscard]] CpuManager& GetCpuManager();
|
2018-05-06 06:54:43 +03:00
|
|
|
|
2020-11-18 10:06:42 +03:00
|
|
|
/// Gets a const reference to the underlying CPU manager
|
|
|
|
[[nodiscard]] const CpuManager& GetCpuManager() const;
|
2018-10-15 16:25:11 +03:00
|
|
|
|
2018-10-29 00:37:31 +03:00
|
|
|
/// Gets a reference to the exclusive monitor
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] ExclusiveMonitor& Monitor();
|
2018-08-30 17:50:54 +03:00
|
|
|
|
2018-10-29 00:37:31 +03:00
|
|
|
/// Gets a constant reference to the exclusive monitor
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] const ExclusiveMonitor& Monitor() const;
|
2018-10-29 00:37:31 +03:00
|
|
|
|
2019-11-26 20:33:20 +03:00
|
|
|
/// Gets a mutable reference to the system memory instance.
|
2023-03-24 02:58:48 +03:00
|
|
|
[[nodiscard]] Core::Memory::Memory& ApplicationMemory();
|
2019-11-26 20:33:20 +03:00
|
|
|
|
|
|
|
/// Gets a constant reference to the system memory instance.
|
2023-03-24 02:58:48 +03:00
|
|
|
[[nodiscard]] const Core::Memory::Memory& ApplicationMemory() const;
|
2019-11-26 20:33:20 +03:00
|
|
|
|
2018-08-03 19:55:58 +03:00
|
|
|
/// Gets a mutable reference to the GPU interface
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] Tegra::GPU& GPU();
|
2018-02-12 07:44:12 +03:00
|
|
|
|
2018-08-03 19:55:58 +03:00
|
|
|
/// Gets an immutable reference to the GPU interface.
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] const Tegra::GPU& GPU() const;
|
2018-08-03 19:55:58 +03:00
|
|
|
|
2022-01-30 12:31:13 +03:00
|
|
|
/// Gets a mutable reference to the Host1x interface
|
|
|
|
[[nodiscard]] Tegra::Host1x::Host1x& Host1x();
|
|
|
|
|
|
|
|
/// Gets an immutable reference to the Host1x interface.
|
|
|
|
[[nodiscard]] const Tegra::Host1x::Host1x& Host1x() const;
|
|
|
|
|
2018-08-03 19:55:58 +03:00
|
|
|
/// Gets a mutable reference to the renderer.
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] VideoCore::RendererBase& Renderer();
|
2018-08-03 19:55:58 +03:00
|
|
|
|
|
|
|
/// Gets an immutable reference to the renderer.
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] const VideoCore::RendererBase& Renderer() const;
|
2018-07-03 16:28:46 +03:00
|
|
|
|
2022-07-17 01:48:45 +03:00
|
|
|
/// Gets a mutable reference to the audio interface
|
|
|
|
[[nodiscard]] AudioCore::AudioCore& AudioCore();
|
|
|
|
|
|
|
|
/// Gets an immutable reference to the audio interface.
|
|
|
|
[[nodiscard]] const AudioCore::AudioCore& AudioCore() const;
|
|
|
|
|
2019-03-30 00:02:57 +03:00
|
|
|
/// Gets the global scheduler
|
2020-12-03 05:08:35 +03:00
|
|
|
[[nodiscard]] Kernel::GlobalSchedulerContext& GlobalSchedulerContext();
|
2019-03-30 00:02:57 +03:00
|
|
|
|
|
|
|
/// Gets the global scheduler
|
2020-12-03 05:08:35 +03:00
|
|
|
[[nodiscard]] const Kernel::GlobalSchedulerContext& GlobalSchedulerContext() const;
|
2019-03-30 00:02:57 +03:00
|
|
|
|
2020-04-03 05:00:41 +03:00
|
|
|
/// Gets the manager for the guest device memory
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] Core::DeviceMemory& DeviceMemory();
|
2020-04-03 05:00:41 +03:00
|
|
|
|
|
|
|
/// Gets the manager for the guest device memory
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] const Core::DeviceMemory& DeviceMemory() const;
|
2020-04-03 05:00:41 +03:00
|
|
|
|
2023-02-13 19:21:43 +03:00
|
|
|
/// Provides a pointer to the application process
|
|
|
|
[[nodiscard]] Kernel::KProcess* ApplicationProcess();
|
2018-03-14 00:49:59 +03:00
|
|
|
|
2023-02-13 19:21:43 +03:00
|
|
|
/// Provides a constant pointer to the application process.
|
|
|
|
[[nodiscard]] const Kernel::KProcess* ApplicationProcess() const;
|
2018-09-07 03:34:51 +03:00
|
|
|
|
2019-02-14 20:42:58 +03:00
|
|
|
/// Provides a reference to the core timing instance.
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] Timing::CoreTiming& CoreTiming();
|
2019-02-14 20:42:58 +03:00
|
|
|
|
|
|
|
/// Provides a constant reference to the core timing instance.
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] const Timing::CoreTiming& CoreTiming() const;
|
2019-02-14 20:42:58 +03:00
|
|
|
|
2018-08-28 19:30:33 +03:00
|
|
|
/// Provides a reference to the kernel instance.
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] Kernel::KernelCore& Kernel();
|
2018-08-28 19:30:33 +03:00
|
|
|
|
|
|
|
/// Provides a constant reference to the kernel instance.
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] const Kernel::KernelCore& Kernel() const;
|
2018-08-28 19:30:33 +03:00
|
|
|
|
2021-10-23 07:04:06 +03:00
|
|
|
/// Gets a mutable reference to the HID interface.
|
2021-09-21 03:44:34 +03:00
|
|
|
[[nodiscard]] HID::HIDCore& HIDCore();
|
|
|
|
|
|
|
|
/// Gets an immutable reference to the HID interface.
|
|
|
|
[[nodiscard]] const HID::HIDCore& HIDCore() const;
|
|
|
|
|
2018-08-30 17:50:54 +03:00
|
|
|
/// Provides a reference to the internal PerfStats instance.
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] Core::PerfStats& GetPerfStats();
|
2018-08-23 21:12:56 +03:00
|
|
|
|
2018-08-30 17:50:54 +03:00
|
|
|
/// Provides a constant reference to the internal PerfStats instance.
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] const Core::PerfStats& GetPerfStats() const;
|
2017-02-20 01:34:47 +03:00
|
|
|
|
2021-07-23 02:56:21 +03:00
|
|
|
/// Provides a reference to the speed limiter;
|
|
|
|
[[nodiscard]] Core::SpeedLimiter& SpeedLimiter();
|
2017-04-13 08:15:23 +03:00
|
|
|
|
2021-07-23 02:56:21 +03:00
|
|
|
/// Provides a constant reference to the speed limiter
|
|
|
|
[[nodiscard]] const Core::SpeedLimiter& SpeedLimiter() const;
|
2017-03-09 00:28:30 +03:00
|
|
|
|
2023-02-13 19:21:43 +03:00
|
|
|
[[nodiscard]] u64 GetApplicationProcessProgramID() const;
|
2021-11-04 03:32:26 +03:00
|
|
|
|
2018-08-30 17:50:54 +03:00
|
|
|
/// Gets the name of the current game
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] Loader::ResultStatus GetGameName(std::string& out) const;
|
2018-08-30 17:50:54 +03:00
|
|
|
|
2021-10-15 01:14:40 +03:00
|
|
|
void SetStatus(SystemResultStatus new_status, const char* details);
|
2018-08-30 17:50:54 +03:00
|
|
|
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] const std::string& GetStatusDetails() const;
|
2018-08-30 17:50:54 +03:00
|
|
|
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] Loader::AppLoader& GetAppLoader();
|
|
|
|
[[nodiscard]] const Loader::AppLoader& GetAppLoader() const;
|
2017-08-02 02:53:35 +03:00
|
|
|
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] Service::SM::ServiceManager& ServiceManager();
|
|
|
|
[[nodiscard]] const Service::SM::ServiceManager& ServiceManager() const;
|
2018-04-21 02:29:04 +03:00
|
|
|
|
2020-09-17 01:14:43 +03:00
|
|
|
void SetFilesystem(FileSys::VirtualFilesystem vfs);
|
2018-08-03 18:51:48 +03:00
|
|
|
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] FileSys::VirtualFilesystem GetFilesystem() const;
|
2018-08-03 18:51:48 +03:00
|
|
|
|
2019-05-31 02:36:18 +03:00
|
|
|
void RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
|
2023-03-18 04:26:04 +03:00
|
|
|
const std::array<u8, 0x20>& build_id, u64 main_region_begin,
|
2019-05-31 02:36:18 +03:00
|
|
|
u64 main_region_size);
|
2018-12-23 05:32:05 +03:00
|
|
|
|
2019-03-12 02:33:49 +03:00
|
|
|
void SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set);
|
|
|
|
void SetDefaultAppletFrontendSet();
|
2018-11-12 00:39:25 +03:00
|
|
|
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] Service::AM::Applets::AppletManager& GetAppletManager();
|
|
|
|
[[nodiscard]] const Service::AM::Applets::AppletManager& GetAppletManager() const;
|
2018-12-25 00:22:07 +03:00
|
|
|
|
2018-12-28 08:03:01 +03:00
|
|
|
void SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider);
|
|
|
|
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] FileSys::ContentProvider& GetContentProvider();
|
|
|
|
[[nodiscard]] const FileSys::ContentProvider& GetContentProvider() const;
|
2018-12-28 08:03:01 +03:00
|
|
|
|
2023-07-22 02:22:14 +03:00
|
|
|
[[nodiscard]] FileSys::ContentProviderUnion& GetContentProviderUnion();
|
|
|
|
[[nodiscard]] const FileSys::ContentProviderUnion& GetContentProviderUnion() const;
|
|
|
|
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] Service::FileSystem::FileSystemController& GetFileSystemController();
|
|
|
|
[[nodiscard]] const Service::FileSystem::FileSystemController& GetFileSystemController() const;
|
2019-04-23 15:35:33 +03:00
|
|
|
|
2018-12-28 08:03:01 +03:00
|
|
|
void RegisterContentProvider(FileSys::ContentProviderUnionSlot slot,
|
|
|
|
FileSys::ContentProvider* provider);
|
|
|
|
|
|
|
|
void ClearContentProvider(FileSys::ContentProviderUnionSlot slot);
|
|
|
|
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] const Reporter& GetReporter() const;
|
2019-06-25 02:27:35 +03:00
|
|
|
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] Service::Glue::ARPManager& GetARPManager();
|
|
|
|
[[nodiscard]] const Service::Glue::ARPManager& GetARPManager() const;
|
2019-06-25 02:27:35 +03:00
|
|
|
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] Service::APM::Controller& GetAPMController();
|
|
|
|
[[nodiscard]] const Service::APM::Controller& GetAPMController() const;
|
2019-06-29 05:46:31 +03:00
|
|
|
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] Service::Time::TimeManager& GetTimeManager();
|
|
|
|
[[nodiscard]] const Service::Time::TimeManager& GetTimeManager() const;
|
2020-10-13 04:09:15 +03:00
|
|
|
|
2022-05-31 02:35:01 +03:00
|
|
|
[[nodiscard]] Core::Debugger& GetDebugger();
|
|
|
|
[[nodiscard]] const Core::Debugger& GetDebugger() const;
|
|
|
|
|
2022-07-22 17:31:13 +03:00
|
|
|
/// Gets a mutable reference to the Room Network.
|
|
|
|
[[nodiscard]] Network::RoomNetwork& GetRoomNetwork();
|
|
|
|
|
|
|
|
/// Gets an immutable reference to the Room Network.
|
|
|
|
[[nodiscard]] const Network::RoomNetwork& GetRoomNetwork() const;
|
|
|
|
|
2019-07-06 20:08:33 +03:00
|
|
|
void SetExitLock(bool locked);
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] bool GetExitLock() const;
|
2019-07-06 20:08:33 +03:00
|
|
|
|
2023-02-13 19:21:43 +03:00
|
|
|
void SetApplicationProcessBuildID(const CurrentBuildProcessID& id);
|
|
|
|
[[nodiscard]] const CurrentBuildProcessID& GetApplicationProcessBuildID() const;
|
2019-04-29 01:43:48 +03:00
|
|
|
|
2020-02-22 18:13:07 +03:00
|
|
|
/// Register a host thread as an emulated CPU Core.
|
|
|
|
void RegisterCoreThread(std::size_t id);
|
|
|
|
|
|
|
|
/// Register a host thread as an auxiliary thread.
|
|
|
|
void RegisterHostThread();
|
|
|
|
|
2023-06-13 04:34:25 +03:00
|
|
|
/// Enter CPU Microprofile
|
|
|
|
void EnterCPUProfile();
|
2020-03-12 23:48:43 +03:00
|
|
|
|
2023-06-13 04:34:25 +03:00
|
|
|
/// Exit CPU Microprofile
|
|
|
|
void ExitCPUProfile();
|
2020-03-12 23:48:43 +03:00
|
|
|
|
2020-05-29 22:00:17 +03:00
|
|
|
/// Tells if system is running on multicore.
|
2020-11-18 10:06:42 +03:00
|
|
|
[[nodiscard]] bool IsMulticore() const;
|
2020-05-29 22:00:17 +03:00
|
|
|
|
2022-05-31 02:35:01 +03:00
|
|
|
/// Tells if the system debugger is enabled.
|
|
|
|
[[nodiscard]] bool DebuggerEnabled() const;
|
|
|
|
|
2023-02-19 00:26:48 +03:00
|
|
|
/// Runs a server instance until shutdown.
|
|
|
|
void RunServer(std::unique_ptr<Service::ServerManager>&& server_manager);
|
|
|
|
|
2020-11-25 02:16:24 +03:00
|
|
|
/// Type used for the frontend to designate a callback for System to re-launch the application
|
|
|
|
/// using a specified program index.
|
|
|
|
using ExecuteProgramCallback = std::function<void(std::size_t)>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Registers a callback from the frontend for System to re-launch the application using a
|
|
|
|
* specified program index.
|
|
|
|
* @param callback Callback from the frontend to relaunch the application.
|
|
|
|
*/
|
|
|
|
void RegisterExecuteProgramCallback(ExecuteProgramCallback&& callback);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Instructs the frontend to re-launch the application using the specified program_index.
|
|
|
|
* @param program_index Specifies the index within the application of the program to launch.
|
|
|
|
*/
|
|
|
|
void ExecuteProgram(std::size_t program_index);
|
|
|
|
|
2021-09-26 06:14:49 +03:00
|
|
|
/// Type used for the frontend to designate a callback for System to exit the application.
|
|
|
|
using ExitCallback = std::function<void()>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Registers a callback from the frontend for System to exit the application.
|
|
|
|
* @param callback Callback from the frontend to exit the application.
|
|
|
|
*/
|
|
|
|
void RegisterExitCallback(ExitCallback&& callback);
|
|
|
|
|
|
|
|
/// Instructs the frontend to exit the application.
|
|
|
|
void Exit();
|
|
|
|
|
2021-04-15 02:07:40 +03:00
|
|
|
/// Applies any changes to settings to this core instance.
|
|
|
|
void ApplySettings();
|
|
|
|
|
2016-12-16 03:01:48 +03:00
|
|
|
private:
|
2018-08-30 17:50:54 +03:00
|
|
|
struct Impl;
|
|
|
|
std::unique_ptr<Impl> impl;
|
2016-12-16 03:01:48 +03:00
|
|
|
};
|
2013-09-06 02:33:46 +04:00
|
|
|
|
2016-12-16 03:01:48 +03:00
|
|
|
} // namespace Core
|