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 00:06:02 +00:00
|
|
|
// SPDX-FileCopyrightText: 2014 Citra Emulator Project
|
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2013-09-05 22:33:46 +00:00
|
|
|
|
2018-08-31 16:21:34 +00:00
|
|
|
#include <array>
|
2021-06-22 07:22:19 +00:00
|
|
|
#include <atomic>
|
2021-08-24 05:32:38 +00:00
|
|
|
#include <exception>
|
2015-12-29 23:03:08 +00:00
|
|
|
#include <memory>
|
2017-03-09 01:21:31 +00:00
|
|
|
#include <utility>
|
2018-08-31 16:21:34 +00:00
|
|
|
|
2022-07-16 22:48:45 +00:00
|
|
|
#include "audio_core/audio_core.h"
|
2021-05-25 23:32:56 +00:00
|
|
|
#include "common/fs/fs.h"
|
2015-05-06 07:06:12 +00:00
|
|
|
#include "common/logging/log.h"
|
2020-03-12 20:48:43 +00:00
|
|
|
#include "common/microprofile.h"
|
2021-04-14 23:07:40 +00:00
|
|
|
#include "common/settings.h"
|
2018-08-10 01:33:13 +00:00
|
|
|
#include "common/string_util.h"
|
2018-08-31 16:21:34 +00:00
|
|
|
#include "core/arm/exclusive_monitor.h"
|
2016-09-21 06:52:38 +00:00
|
|
|
#include "core/core.h"
|
2016-09-02 03:18:01 +00:00
|
|
|
#include "core/core_timing.h"
|
2020-01-26 18:07:22 +00:00
|
|
|
#include "core/cpu_manager.h"
|
2022-05-30 23:35:01 +00:00
|
|
|
#include "core/debugger/debugger.h"
|
2020-04-03 02:00:41 +00:00
|
|
|
#include "core/device_memory.h"
|
2019-04-23 12:35:33 +00:00
|
|
|
#include "core/file_sys/bis_factory.h"
|
2018-09-02 14:53:06 +00:00
|
|
|
#include "core/file_sys/mode.h"
|
2019-09-21 22:13:10 +00:00
|
|
|
#include "core/file_sys/patch_manager.h"
|
2018-12-28 05:03:01 +00:00
|
|
|
#include "core/file_sys/registered_cache.h"
|
2019-04-23 12:35:33 +00:00
|
|
|
#include "core/file_sys/romfs_factory.h"
|
|
|
|
#include "core/file_sys/savedata_factory.h"
|
2018-09-02 14:53:06 +00:00
|
|
|
#include "core/file_sys/vfs_concat.h"
|
|
|
|
#include "core/file_sys/vfs_real.h"
|
2021-09-21 00:44:34 +00:00
|
|
|
#include "core/hid/hid_core.h"
|
2022-02-21 20:33:17 +00:00
|
|
|
#include "core/hle/kernel/k_memory_manager.h"
|
2021-04-24 05:04:28 +00:00
|
|
|
#include "core/hle/kernel/k_process.h"
|
2022-02-21 20:33:17 +00:00
|
|
|
#include "core/hle/kernel/k_resource_limit.h"
|
2020-12-03 02:08:35 +00:00
|
|
|
#include "core/hle/kernel/k_scheduler.h"
|
2016-12-16 00:01:48 +00:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
2020-01-25 22:55:32 +00:00
|
|
|
#include "core/hle/kernel/physical_core.h"
|
2019-03-11 23:33:49 +00:00
|
|
|
#include "core/hle/service/am/applets/applets.h"
|
2021-07-14 04:52:17 +00:00
|
|
|
#include "core/hle/service/apm/apm_controller.h"
|
2019-04-23 12:35:33 +00:00
|
|
|
#include "core/hle/service/filesystem/filesystem.h"
|
2021-07-14 04:52:17 +00:00
|
|
|
#include "core/hle/service/glue/glue_manager.h"
|
2016-12-16 05:37:38 +00:00
|
|
|
#include "core/hle/service/service.h"
|
2018-04-20 23:29:04 +00:00
|
|
|
#include "core/hle/service/sm/sm.h"
|
2020-10-13 01:09:15 +00:00
|
|
|
#include "core/hle/service/time/time_manager.h"
|
2021-12-25 19:27:52 +00:00
|
|
|
#include "core/internal_network/network.h"
|
2016-12-16 00:01:48 +00:00
|
|
|
#include "core/loader/loader.h"
|
2019-11-26 17:33:20 +00:00
|
|
|
#include "core/memory.h"
|
2019-05-30 23:36:18 +00:00
|
|
|
#include "core/memory/cheat_engine.h"
|
2018-08-31 16:21:34 +00:00
|
|
|
#include "core/perf_stats.h"
|
2019-05-18 01:45:56 +00:00
|
|
|
#include "core/reporter.h"
|
2018-08-31 16:21:34 +00:00
|
|
|
#include "core/telemetry_session.h"
|
2019-06-07 15:11:11 +00:00
|
|
|
#include "core/tools/freezer.h"
|
2021-12-25 19:27:52 +00:00
|
|
|
#include "network/network.h"
|
2022-01-30 09:31:13 +00:00
|
|
|
#include "video_core/host1x/host1x.h"
|
2018-08-03 16:55:58 +00:00
|
|
|
#include "video_core/renderer_base.h"
|
2016-12-16 00:01:48 +00:00
|
|
|
#include "video_core/video_core.h"
|
2015-09-02 12:56:38 +00:00
|
|
|
|
2020-04-12 23:25:53 +00:00
|
|
|
MICROPROFILE_DEFINE(ARM_Jit_Dynarmic_CPU0, "ARM JIT", "Dynarmic CPU 0", MP_RGB(255, 64, 64));
|
|
|
|
MICROPROFILE_DEFINE(ARM_Jit_Dynarmic_CPU1, "ARM JIT", "Dynarmic CPU 1", MP_RGB(255, 64, 64));
|
|
|
|
MICROPROFILE_DEFINE(ARM_Jit_Dynarmic_CPU2, "ARM JIT", "Dynarmic CPU 2", MP_RGB(255, 64, 64));
|
|
|
|
MICROPROFILE_DEFINE(ARM_Jit_Dynarmic_CPU3, "ARM JIT", "Dynarmic CPU 3", MP_RGB(255, 64, 64));
|
2020-03-12 20:48:43 +00:00
|
|
|
|
2013-09-05 22:33:46 +00:00
|
|
|
namespace Core {
|
|
|
|
|
2019-06-24 23:27:35 +00:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
FileSys::StorageId GetStorageIdForFrontendSlot(
|
|
|
|
std::optional<FileSys::ContentProviderUnionSlot> slot) {
|
|
|
|
if (!slot.has_value()) {
|
|
|
|
return FileSys::StorageId::None;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (*slot) {
|
|
|
|
case FileSys::ContentProviderUnionSlot::UserNAND:
|
|
|
|
return FileSys::StorageId::NandUser;
|
|
|
|
case FileSys::ContentProviderUnionSlot::SysNAND:
|
|
|
|
return FileSys::StorageId::NandSystem;
|
|
|
|
case FileSys::ContentProviderUnionSlot::SDMC:
|
|
|
|
return FileSys::StorageId::SdCard;
|
|
|
|
case FileSys::ContentProviderUnionSlot::FrontendManual:
|
|
|
|
return FileSys::StorageId::Host;
|
|
|
|
default:
|
|
|
|
return FileSys::StorageId::None;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} // Anonymous namespace
|
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
|
|
|
|
const std::string& path) {
|
|
|
|
// To account for split 00+01+etc files.
|
|
|
|
std::string dir_name;
|
|
|
|
std::string filename;
|
|
|
|
Common::SplitPath(path, &dir_name, &filename, nullptr);
|
2020-11-26 19:03:27 +00:00
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
if (filename == "00") {
|
|
|
|
const auto dir = vfs->OpenDirectory(dir_name, FileSys::Mode::Read);
|
|
|
|
std::vector<FileSys::VirtualFile> concat;
|
2020-11-26 19:03:27 +00:00
|
|
|
|
|
|
|
for (u32 i = 0; i < 0x10; ++i) {
|
|
|
|
const auto file_name = fmt::format("{:02X}", i);
|
|
|
|
auto next = dir->GetFile(file_name);
|
|
|
|
|
|
|
|
if (next != nullptr) {
|
2018-08-30 14:50:54 +00:00
|
|
|
concat.push_back(std::move(next));
|
2020-11-26 19:03:27 +00:00
|
|
|
} else {
|
|
|
|
next = dir->GetFile(file_name);
|
|
|
|
|
|
|
|
if (next == nullptr) {
|
2018-08-30 14:50:54 +00:00
|
|
|
break;
|
2020-11-26 19:03:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
concat.push_back(std::move(next));
|
2018-08-30 14:50:54 +00:00
|
|
|
}
|
|
|
|
}
|
2018-07-18 22:15:16 +00:00
|
|
|
|
2020-11-26 19:03:27 +00:00
|
|
|
if (concat.empty()) {
|
2018-08-30 14:50:54 +00:00
|
|
|
return nullptr;
|
2020-11-26 19:03:27 +00:00
|
|
|
}
|
2018-08-30 14:50:54 +00:00
|
|
|
|
2020-11-26 19:03:27 +00:00
|
|
|
return FileSys::ConcatenatedVfsFile::MakeConcatenatedFile(std::move(concat),
|
|
|
|
dir->GetName());
|
2018-08-30 14:50:54 +00:00
|
|
|
}
|
|
|
|
|
2021-05-25 23:32:56 +00:00
|
|
|
if (Common::FS::IsDir(path)) {
|
2020-11-26 19:03:27 +00:00
|
|
|
return vfs->OpenFile(path + "/main", FileSys::Mode::Read);
|
|
|
|
}
|
2018-11-28 19:00:44 +00:00
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
return vfs->OpenFile(path, FileSys::Mode::Read);
|
|
|
|
}
|
2020-11-26 19:03:27 +00:00
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
struct System::Impl {
|
2019-07-11 04:53:55 +00:00
|
|
|
explicit Impl(System& system)
|
2022-07-22 14:31:13 +00:00
|
|
|
: kernel{system}, fs_controller{system}, memory{system}, hid_core{}, room_network{},
|
2020-10-13 01:09:15 +00:00
|
|
|
cpu_manager{system}, reporter{system}, applet_manager{system}, time_manager{system} {}
|
2018-11-28 19:00:44 +00:00
|
|
|
|
2022-09-10 08:48:15 +00:00
|
|
|
void Initialize(System& system) {
|
|
|
|
device_memory = std::make_unique<Core::DeviceMemory>();
|
|
|
|
|
|
|
|
is_multicore = Settings::values.use_multi_core.GetValue();
|
|
|
|
|
|
|
|
core_timing.SetMulticore(is_multicore);
|
|
|
|
core_timing.Initialize([&system]() { system.RegisterHostThread(); });
|
|
|
|
|
|
|
|
const auto posix_time = std::chrono::system_clock::now().time_since_epoch();
|
|
|
|
const auto current_time =
|
|
|
|
std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
|
|
|
|
Settings::values.custom_rtc_differential =
|
|
|
|
Settings::values.custom_rtc.value_or(current_time) - current_time;
|
|
|
|
|
|
|
|
// Create a default fs if one doesn't already exist.
|
2022-10-19 02:12:18 +00:00
|
|
|
if (virtual_filesystem == nullptr) {
|
2022-09-10 08:48:15 +00:00
|
|
|
virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
|
2022-10-19 02:12:18 +00:00
|
|
|
}
|
|
|
|
if (content_provider == nullptr) {
|
2022-09-10 08:48:15 +00:00
|
|
|
content_provider = std::make_unique<FileSys::ContentProviderUnion>();
|
2022-10-19 02:12:18 +00:00
|
|
|
}
|
2022-09-10 08:48:15 +00:00
|
|
|
|
|
|
|
// Create default implementations of applets if one is not provided.
|
|
|
|
applet_manager.SetDefaultAppletsIfMissing();
|
2022-10-15 07:48:28 +00:00
|
|
|
|
|
|
|
is_async_gpu = Settings::values.use_asynchronous_gpu_emulation.GetValue();
|
|
|
|
|
|
|
|
kernel.SetMulticore(is_multicore);
|
|
|
|
cpu_manager.SetMulticore(is_multicore);
|
|
|
|
cpu_manager.SetAsyncGpu(is_async_gpu);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ReinitializeIfNecessary(System& system) {
|
|
|
|
if (is_multicore == Settings::values.use_multi_core.GetValue()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
LOG_DEBUG(Kernel, "Re-initializing");
|
|
|
|
|
|
|
|
is_multicore = Settings::values.use_multi_core.GetValue();
|
|
|
|
|
|
|
|
Initialize(system);
|
2022-09-10 08:48:15 +00:00
|
|
|
}
|
|
|
|
|
2021-10-14 22:14:40 +00:00
|
|
|
SystemResultStatus Run() {
|
2021-10-05 21:54:33 +00:00
|
|
|
std::unique_lock<std::mutex> lk(suspend_guard);
|
2021-10-14 22:14:40 +00:00
|
|
|
status = SystemResultStatus::Success;
|
2018-05-08 02:57:39 +00:00
|
|
|
|
2020-02-25 02:04:12 +00:00
|
|
|
kernel.Suspend(false);
|
|
|
|
core_timing.SyncPause(false);
|
2021-10-05 21:54:33 +00:00
|
|
|
is_paused = false;
|
2020-02-25 02:04:12 +00:00
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2021-10-14 22:14:40 +00:00
|
|
|
SystemResultStatus Pause() {
|
2021-10-05 21:54:33 +00:00
|
|
|
std::unique_lock<std::mutex> lk(suspend_guard);
|
2021-10-14 22:14:40 +00:00
|
|
|
status = SystemResultStatus::Success;
|
2020-02-25 02:04:12 +00:00
|
|
|
|
|
|
|
core_timing.SyncPause(true);
|
2020-02-25 16:28:55 +00:00
|
|
|
kernel.Suspend(true);
|
2021-10-05 21:54:33 +00:00
|
|
|
is_paused = true;
|
2018-08-30 14:50:54 +00:00
|
|
|
|
|
|
|
return status;
|
2015-09-02 12:56:38 +00:00
|
|
|
}
|
|
|
|
|
2022-07-16 22:48:45 +00:00
|
|
|
bool IsPaused() const {
|
|
|
|
std::unique_lock lk(suspend_guard);
|
|
|
|
return is_paused;
|
|
|
|
}
|
|
|
|
|
2022-06-13 22:36:30 +00:00
|
|
|
std::unique_lock<std::mutex> StallProcesses() {
|
2021-10-15 22:20:19 +00:00
|
|
|
std::unique_lock<std::mutex> lk(suspend_guard);
|
|
|
|
kernel.Suspend(true);
|
|
|
|
core_timing.SyncPause(true);
|
|
|
|
return lk;
|
|
|
|
}
|
|
|
|
|
2022-06-13 22:36:30 +00:00
|
|
|
void UnstallProcesses() {
|
2021-10-15 22:20:19 +00:00
|
|
|
if (!is_paused) {
|
|
|
|
core_timing.SyncPause(false);
|
|
|
|
kernel.Suspend(false);
|
2021-10-05 21:54:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-30 23:35:01 +00:00
|
|
|
void InitializeDebugger(System& system, u16 port) {
|
|
|
|
debugger = std::make_unique<Debugger>(system, port);
|
|
|
|
}
|
|
|
|
|
2022-09-10 08:48:15 +00:00
|
|
|
SystemResultStatus SetupForMainProcess(System& system, Frontend::EmuWindow& emu_window) {
|
2020-11-24 23:16:24 +00:00
|
|
|
LOG_DEBUG(Core, "initialized OK");
|
2018-08-30 14:50:54 +00:00
|
|
|
|
2022-10-15 07:48:28 +00:00
|
|
|
// Setting changes may require a full system reinitialization (e.g., disabling multicore).
|
|
|
|
ReinitializeIfNecessary(system);
|
2020-03-09 02:39:41 +00:00
|
|
|
|
2019-03-05 17:28:10 +00:00
|
|
|
kernel.Initialize();
|
2020-01-26 18:07:22 +00:00
|
|
|
cpu_manager.Initialize();
|
2018-11-11 21:39:25 +00:00
|
|
|
|
2019-06-24 23:27:35 +00:00
|
|
|
/// Reset all glue registrations
|
|
|
|
arp_manager.ResetAll();
|
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
telemetry_session = std::make_unique<Core::TelemetrySession>();
|
2020-10-31 06:16:35 +00:00
|
|
|
|
2022-01-30 21:26:01 +00:00
|
|
|
host1x_core = std::make_unique<Tegra::Host1x::Host1x>(system);
|
2020-10-31 06:16:35 +00:00
|
|
|
gpu_core = VideoCore::CreateGPU(emu_window, system);
|
|
|
|
if (!gpu_core) {
|
2021-10-14 22:14:40 +00:00
|
|
|
return SystemResultStatus::ErrorVideoCore;
|
2020-10-31 06:16:35 +00:00
|
|
|
}
|
|
|
|
|
2022-07-16 22:48:45 +00:00
|
|
|
audio_core = std::make_unique<AudioCore::AudioCore>(system);
|
|
|
|
|
2020-09-17 14:43:54 +00:00
|
|
|
service_manager = std::make_shared<Service::SM::ServiceManager>(kernel);
|
2020-11-24 22:31:58 +00:00
|
|
|
services = std::make_unique<Service::Services>(service_manager, system);
|
2019-01-08 02:42:32 +00:00
|
|
|
|
2020-10-13 01:09:15 +00:00
|
|
|
// Initialize time manager, which must happen after kernel is created
|
|
|
|
time_manager.Initialize();
|
|
|
|
|
2019-04-09 18:02:00 +00:00
|
|
|
is_powered_on = true;
|
2019-07-06 17:08:33 +00:00
|
|
|
exit_lock = false;
|
2018-08-30 14:50:54 +00:00
|
|
|
|
2020-04-12 23:25:53 +00:00
|
|
|
microprofile_dynarmic[0] = MICROPROFILE_TOKEN(ARM_Jit_Dynarmic_CPU0);
|
|
|
|
microprofile_dynarmic[1] = MICROPROFILE_TOKEN(ARM_Jit_Dynarmic_CPU1);
|
|
|
|
microprofile_dynarmic[2] = MICROPROFILE_TOKEN(ARM_Jit_Dynarmic_CPU2);
|
|
|
|
microprofile_dynarmic[3] = MICROPROFILE_TOKEN(ARM_Jit_Dynarmic_CPU3);
|
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
LOG_DEBUG(Core, "Initialized OK");
|
|
|
|
|
2021-10-14 22:14:40 +00:00
|
|
|
return SystemResultStatus::Success;
|
2018-08-07 02:01:24 +00:00
|
|
|
}
|
|
|
|
|
2021-10-14 22:14:40 +00:00
|
|
|
SystemResultStatus Load(System& system, Frontend::EmuWindow& emu_window,
|
|
|
|
const std::string& filepath, u64 program_id,
|
|
|
|
std::size_t program_index) {
|
2020-11-24 23:16:24 +00:00
|
|
|
app_loader = Loader::GetLoader(system, GetGameFileFromPath(virtual_filesystem, filepath),
|
2021-07-20 05:10:05 +00:00
|
|
|
program_id, program_index);
|
2020-11-24 23:16:24 +00:00
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
if (!app_loader) {
|
|
|
|
LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
|
2021-10-14 22:14:40 +00:00
|
|
|
return SystemResultStatus::ErrorGetLoader;
|
2018-08-30 14:50:54 +00:00
|
|
|
}
|
2018-08-10 00:48:41 +00:00
|
|
|
|
2022-09-10 08:48:15 +00:00
|
|
|
SystemResultStatus init_result{SetupForMainProcess(system, emu_window)};
|
2021-10-14 22:14:40 +00:00
|
|
|
if (init_result != SystemResultStatus::Success) {
|
2018-08-30 14:50:54 +00:00
|
|
|
LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
|
|
|
|
static_cast<int>(init_result));
|
2022-09-10 08:48:15 +00:00
|
|
|
ShutdownMainProcess();
|
2018-08-30 14:50:54 +00:00
|
|
|
return init_result;
|
|
|
|
}
|
2018-08-10 00:48:41 +00:00
|
|
|
|
2020-11-18 12:53:10 +00:00
|
|
|
telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
|
2022-02-21 20:33:17 +00:00
|
|
|
|
|
|
|
// Create a resource limit for the process.
|
|
|
|
const auto physical_memory_size =
|
|
|
|
kernel.MemoryManager().GetSize(Kernel::KMemoryManager::Pool::Application);
|
|
|
|
auto* resource_limit = Kernel::CreateResourceLimitForProcess(system, physical_memory_size);
|
|
|
|
|
|
|
|
// Create the process.
|
2021-10-26 04:43:27 +00:00
|
|
|
auto main_process = Kernel::KProcess::Create(system.Kernel());
|
|
|
|
ASSERT(Kernel::KProcess::Initialize(main_process, system, "main",
|
2022-02-21 20:33:17 +00:00
|
|
|
Kernel::KProcess::ProcessType::Userland, resource_limit)
|
2021-04-04 05:22:36 +00:00
|
|
|
.IsSuccess());
|
2020-09-16 12:19:25 +00:00
|
|
|
const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
|
2018-08-30 14:50:54 +00:00
|
|
|
if (load_result != Loader::ResultStatus::Success) {
|
2020-12-08 03:00:34 +00:00
|
|
|
LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", load_result);
|
2022-09-10 08:48:15 +00:00
|
|
|
ShutdownMainProcess();
|
2018-08-30 14:50:54 +00:00
|
|
|
|
2021-10-14 22:14:40 +00:00
|
|
|
return static_cast<SystemResultStatus>(
|
|
|
|
static_cast<u32>(SystemResultStatus::ErrorLoader) + static_cast<u32>(load_result));
|
2018-08-30 14:50:54 +00:00
|
|
|
}
|
2019-06-24 23:27:35 +00:00
|
|
|
AddGlueRegistrationForProcess(*app_loader, *main_process);
|
2021-10-26 04:43:27 +00:00
|
|
|
kernel.MakeCurrentProcess(main_process);
|
2020-11-13 19:11:12 +00:00
|
|
|
kernel.InitializeCores();
|
2019-01-14 01:05:53 +00:00
|
|
|
|
2019-05-30 23:37:18 +00:00
|
|
|
// Initialize cheat engine
|
|
|
|
if (cheat_engine) {
|
|
|
|
cheat_engine->Initialize();
|
|
|
|
}
|
|
|
|
|
2019-04-09 21:03:04 +00:00
|
|
|
// All threads are started, begin main process execution, now that we're in the clear.
|
|
|
|
main_process->Run(load_parameters->main_thread_priority,
|
|
|
|
load_parameters->main_thread_stack_size);
|
|
|
|
|
2019-04-23 12:35:33 +00:00
|
|
|
if (Settings::values.gamecard_inserted) {
|
|
|
|
if (Settings::values.gamecard_current_game) {
|
|
|
|
fs_controller.SetGameCard(GetGameFileFromPath(virtual_filesystem, filepath));
|
2021-06-28 19:58:16 +00:00
|
|
|
} else if (!Settings::values.gamecard_path.GetValue().empty()) {
|
2022-07-16 22:48:45 +00:00
|
|
|
const auto& gamecard_path = Settings::values.gamecard_path.GetValue();
|
2021-07-08 18:07:10 +00:00
|
|
|
fs_controller.SetGameCard(GetGameFileFromPath(virtual_filesystem, gamecard_path));
|
2019-04-23 12:35:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-20 05:10:05 +00:00
|
|
|
if (app_loader->ReadProgramId(program_id) != Loader::ResultStatus::Success) {
|
2020-12-08 03:00:34 +00:00
|
|
|
LOG_ERROR(Core, "Failed to find title id for ROM (Error {})", load_result);
|
2019-08-26 15:29:08 +00:00
|
|
|
}
|
2021-07-20 05:10:05 +00:00
|
|
|
perf_stats = std::make_unique<PerfStats>(program_id);
|
2019-08-26 15:29:08 +00:00
|
|
|
// Reset counters and set time origin to current frame
|
|
|
|
GetAndResetPerfStats();
|
|
|
|
perf_stats->BeginSystemFrame();
|
|
|
|
|
2021-12-25 19:27:52 +00:00
|
|
|
std::string name = "Unknown Game";
|
2022-07-07 14:54:20 +00:00
|
|
|
if (app_loader->ReadTitle(name) != Loader::ResultStatus::Success) {
|
|
|
|
LOG_ERROR(Core, "Failed to read title for ROM (Error {})", load_result);
|
|
|
|
}
|
2022-08-27 01:31:17 +00:00
|
|
|
|
|
|
|
std::string title_version;
|
|
|
|
const FileSys::PatchManager pm(program_id, system.GetFileSystemController(),
|
|
|
|
system.GetContentProvider());
|
|
|
|
const auto metadata = pm.GetControlMetadata();
|
|
|
|
if (metadata.first != nullptr) {
|
|
|
|
title_version = metadata.first->GetVersionString();
|
|
|
|
}
|
2022-07-22 14:31:13 +00:00
|
|
|
if (auto room_member = room_network.GetRoomMember().lock()) {
|
2021-12-25 19:27:52 +00:00
|
|
|
Network::GameInfo game_info;
|
|
|
|
game_info.name = name;
|
|
|
|
game_info.id = program_id;
|
2022-08-27 01:31:17 +00:00
|
|
|
game_info.version = title_version;
|
2021-12-25 19:27:52 +00:00
|
|
|
room_member->SendGameInfo(game_info);
|
|
|
|
}
|
|
|
|
|
2021-10-14 22:14:40 +00:00
|
|
|
status = SystemResultStatus::Success;
|
2018-08-30 14:50:54 +00:00
|
|
|
return status;
|
2018-08-10 00:48:41 +00:00
|
|
|
}
|
|
|
|
|
2022-09-10 08:48:15 +00:00
|
|
|
void ShutdownMainProcess() {
|
2022-07-16 22:48:45 +00:00
|
|
|
SetShuttingDown(true);
|
|
|
|
|
2019-10-18 14:12:12 +00:00
|
|
|
// Log last frame performance stats if game was loded
|
|
|
|
if (perf_stats) {
|
2019-10-19 18:47:18 +00:00
|
|
|
const auto perf_results = GetAndResetPerfStats();
|
2020-08-18 18:21:50 +00:00
|
|
|
constexpr auto performance = Common::Telemetry::FieldType::Performance;
|
|
|
|
|
|
|
|
telemetry_session->AddField(performance, "Shutdown_EmulationSpeed",
|
2019-10-19 18:47:18 +00:00
|
|
|
perf_results.emulation_speed * 100.0);
|
2021-05-16 00:34:20 +00:00
|
|
|
telemetry_session->AddField(performance, "Shutdown_Framerate",
|
|
|
|
perf_results.average_game_fps);
|
2020-08-18 18:21:50 +00:00
|
|
|
telemetry_session->AddField(performance, "Shutdown_Frametime",
|
2019-10-19 18:47:18 +00:00
|
|
|
perf_results.frametime * 1000.0);
|
2020-08-18 18:21:50 +00:00
|
|
|
telemetry_session->AddField(performance, "Mean_Frametime_MS",
|
2019-10-19 18:47:18 +00:00
|
|
|
perf_stats->GetMeanFrametime());
|
2019-10-18 14:12:12 +00:00
|
|
|
}
|
2018-08-30 14:50:54 +00:00
|
|
|
|
2018-11-22 06:27:23 +00:00
|
|
|
is_powered_on = false;
|
2019-07-06 17:08:33 +00:00
|
|
|
exit_lock = false;
|
2018-11-22 06:27:23 +00:00
|
|
|
|
2022-03-07 06:39:16 +00:00
|
|
|
if (gpu_core != nullptr) {
|
|
|
|
gpu_core->NotifyShutdown();
|
|
|
|
}
|
2022-01-04 01:31:51 +00:00
|
|
|
|
2022-06-13 22:36:30 +00:00
|
|
|
kernel.ShutdownCores();
|
|
|
|
cpu_manager.Shutdown();
|
2022-05-30 23:35:01 +00:00
|
|
|
debugger.reset();
|
2022-07-16 22:48:45 +00:00
|
|
|
kernel.CloseServices();
|
2020-11-24 22:31:58 +00:00
|
|
|
services.reset();
|
2018-08-30 14:50:54 +00:00
|
|
|
service_manager.reset();
|
2018-12-23 02:32:05 +00:00
|
|
|
cheat_engine.reset();
|
2018-08-30 14:50:54 +00:00
|
|
|
telemetry_session.reset();
|
2021-02-21 01:51:11 +00:00
|
|
|
time_manager.Shutdown();
|
2022-09-10 08:48:15 +00:00
|
|
|
core_timing.ClearPendingEvents();
|
2018-08-30 14:50:54 +00:00
|
|
|
app_loader.reset();
|
2022-07-16 22:48:45 +00:00
|
|
|
audio_core.reset();
|
2021-09-24 00:34:02 +00:00
|
|
|
gpu_core.reset();
|
2022-01-30 09:31:13 +00:00
|
|
|
host1x_core.reset();
|
2021-11-05 00:19:58 +00:00
|
|
|
perf_stats.reset();
|
2021-03-02 05:42:06 +00:00
|
|
|
kernel.Shutdown();
|
2021-04-03 00:06:21 +00:00
|
|
|
memory.Reset();
|
2018-12-28 23:20:29 +00:00
|
|
|
|
2022-07-22 14:31:13 +00:00
|
|
|
if (auto room_member = room_network.GetRoomMember().lock()) {
|
2021-12-25 19:27:52 +00:00
|
|
|
Network::GameInfo game_info{};
|
|
|
|
room_member->SendGameInfo(game_info);
|
|
|
|
}
|
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
LOG_DEBUG(Core, "Shutdown OK");
|
2016-12-16 00:01:48 +00:00
|
|
|
}
|
|
|
|
|
2022-07-16 22:48:45 +00:00
|
|
|
bool IsShuttingDown() const {
|
|
|
|
return is_shutting_down;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetShuttingDown(bool shutting_down) {
|
|
|
|
is_shutting_down = shutting_down;
|
|
|
|
}
|
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
Loader::ResultStatus GetGameName(std::string& out) const {
|
|
|
|
if (app_loader == nullptr)
|
|
|
|
return Loader::ResultStatus::ErrorNotInitialized;
|
|
|
|
return app_loader->ReadTitle(out);
|
|
|
|
}
|
2017-03-08 21:28:30 +00:00
|
|
|
|
2021-04-24 05:04:28 +00:00
|
|
|
void AddGlueRegistrationForProcess(Loader::AppLoader& loader, Kernel::KProcess& process) {
|
2019-06-24 23:27:35 +00:00
|
|
|
std::vector<u8> nacp_data;
|
|
|
|
FileSys::NACP nacp;
|
|
|
|
if (loader.ReadControlData(nacp) == Loader::ResultStatus::Success) {
|
|
|
|
nacp_data = nacp.GetRawBytes();
|
|
|
|
} else {
|
|
|
|
nacp_data.resize(sizeof(FileSys::RawNACP));
|
|
|
|
}
|
|
|
|
|
|
|
|
Service::Glue::ApplicationLaunchProperty launch{};
|
2021-11-03 18:15:51 +00:00
|
|
|
launch.title_id = process.GetProgramID();
|
2019-06-24 23:27:35 +00:00
|
|
|
|
2020-11-18 12:53:10 +00:00
|
|
|
FileSys::PatchManager pm{launch.title_id, fs_controller, *content_provider};
|
2019-06-24 23:27:35 +00:00
|
|
|
launch.version = pm.GetGameVersion().value_or(0);
|
|
|
|
|
|
|
|
// TODO(DarkLordZach): When FSController/Game Card Support is added, if
|
|
|
|
// current_process_game_card use correct StorageId
|
|
|
|
launch.base_game_storage_id = GetStorageIdForFrontendSlot(content_provider->GetSlotForEntry(
|
|
|
|
launch.title_id, FileSys::ContentRecordType::Program));
|
|
|
|
launch.update_storage_id = GetStorageIdForFrontendSlot(content_provider->GetSlotForEntry(
|
|
|
|
FileSys::GetUpdateTitleID(launch.title_id), FileSys::ContentRecordType::Program));
|
|
|
|
|
|
|
|
arp_manager.Register(launch.title_id, launch, std::move(nacp_data));
|
|
|
|
}
|
|
|
|
|
2021-10-14 22:14:40 +00:00
|
|
|
void SetStatus(SystemResultStatus new_status, const char* details = nullptr) {
|
2018-08-30 14:50:54 +00:00
|
|
|
status = new_status;
|
|
|
|
if (details) {
|
|
|
|
status_details = details;
|
|
|
|
}
|
2016-12-16 00:01:48 +00:00
|
|
|
}
|
|
|
|
|
2018-08-31 16:21:34 +00:00
|
|
|
PerfStatsResults GetAndResetPerfStats() {
|
2019-08-26 15:29:08 +00:00
|
|
|
return perf_stats->GetAndResetStats(core_timing.GetGlobalTimeUs());
|
2016-12-16 00:01:48 +00:00
|
|
|
}
|
|
|
|
|
2022-07-16 22:48:45 +00:00
|
|
|
mutable std::mutex suspend_guard;
|
2021-10-05 21:54:33 +00:00
|
|
|
bool is_paused{};
|
2022-07-16 22:48:45 +00:00
|
|
|
std::atomic<bool> is_shutting_down{};
|
2021-10-05 21:54:33 +00:00
|
|
|
|
2019-02-14 17:42:58 +00:00
|
|
|
Timing::CoreTiming core_timing;
|
2018-08-30 14:50:54 +00:00
|
|
|
Kernel::KernelCore kernel;
|
|
|
|
/// RealVfsFilesystem instance
|
|
|
|
FileSys::VirtualFilesystem virtual_filesystem;
|
2018-12-28 05:03:01 +00:00
|
|
|
/// ContentProviderUnion instance
|
|
|
|
std::unique_ptr<FileSys::ContentProviderUnion> content_provider;
|
2019-04-23 12:35:33 +00:00
|
|
|
Service::FileSystem::FileSystemController fs_controller;
|
2018-08-30 14:50:54 +00:00
|
|
|
/// AppLoader used to load the current executing application
|
|
|
|
std::unique_ptr<Loader::AppLoader> app_loader;
|
|
|
|
std::unique_ptr<Tegra::GPU> gpu_core;
|
2022-01-30 09:31:13 +00:00
|
|
|
std::unique_ptr<Tegra::Host1x::Host1x> host1x_core;
|
2020-04-08 23:18:10 +00:00
|
|
|
std::unique_ptr<Core::DeviceMemory> device_memory;
|
2022-07-16 22:48:45 +00:00
|
|
|
std::unique_ptr<AudioCore::AudioCore> audio_core;
|
2020-03-31 19:10:44 +00:00
|
|
|
Core::Memory::Memory memory;
|
2021-09-21 00:44:34 +00:00
|
|
|
Core::HID::HIDCore hid_core;
|
2022-07-22 14:31:13 +00:00
|
|
|
Network::RoomNetwork room_network;
|
|
|
|
|
2020-01-26 18:07:22 +00:00
|
|
|
CpuManager cpu_manager;
|
2021-06-22 07:22:19 +00:00
|
|
|
std::atomic_bool is_powered_on{};
|
2019-07-06 17:08:33 +00:00
|
|
|
bool exit_lock = false;
|
2018-08-30 14:50:54 +00:00
|
|
|
|
2019-06-29 21:17:35 +00:00
|
|
|
Reporter reporter;
|
2019-05-30 23:36:18 +00:00
|
|
|
std::unique_ptr<Memory::CheatEngine> cheat_engine;
|
2019-06-07 15:11:11 +00:00
|
|
|
std::unique_ptr<Tools::Freezer> memory_freezer;
|
2019-04-28 22:43:48 +00:00
|
|
|
std::array<u8, 0x20> build_id{};
|
2018-12-23 02:32:05 +00:00
|
|
|
|
2018-11-11 21:39:25 +00:00
|
|
|
/// Frontend applets
|
2019-03-11 23:33:49 +00:00
|
|
|
Service::AM::Applets::AppletManager applet_manager;
|
2018-11-11 21:39:25 +00:00
|
|
|
|
2019-06-29 02:46:31 +00:00
|
|
|
/// APM (Performance) services
|
|
|
|
Service::APM::Controller apm_controller{core_timing};
|
|
|
|
|
2019-06-29 21:17:35 +00:00
|
|
|
/// Service State
|
2019-06-24 23:27:35 +00:00
|
|
|
Service::Glue::ARPManager arp_manager;
|
2020-10-13 01:09:15 +00:00
|
|
|
Service::Time::TimeManager time_manager;
|
2019-06-24 23:27:35 +00:00
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
/// Service manager
|
|
|
|
std::shared_ptr<Service::SM::ServiceManager> service_manager;
|
|
|
|
|
2020-11-24 22:31:58 +00:00
|
|
|
/// Services
|
|
|
|
std::unique_ptr<Service::Services> services;
|
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
/// Telemetry session for this emulation session
|
|
|
|
std::unique_ptr<Core::TelemetrySession> telemetry_session;
|
|
|
|
|
2020-07-12 00:42:56 +00:00
|
|
|
/// Network instance
|
|
|
|
Network::NetworkInstance network_instance;
|
|
|
|
|
2022-05-30 23:35:01 +00:00
|
|
|
/// Debugger
|
|
|
|
std::unique_ptr<Core::Debugger> debugger;
|
|
|
|
|
2021-10-14 22:14:40 +00:00
|
|
|
SystemResultStatus status = SystemResultStatus::Success;
|
2018-08-30 14:50:54 +00:00
|
|
|
std::string status_details = "";
|
|
|
|
|
2019-08-26 15:29:08 +00:00
|
|
|
std::unique_ptr<Core::PerfStats> perf_stats;
|
2021-07-22 23:56:21 +00:00
|
|
|
Core::SpeedLimiter speed_limiter;
|
2020-03-12 20:48:43 +00:00
|
|
|
|
2020-03-16 01:34:22 +00:00
|
|
|
bool is_multicore{};
|
|
|
|
bool is_async_gpu{};
|
|
|
|
|
2020-11-24 23:16:24 +00:00
|
|
|
ExecuteProgramCallback execute_program_callback;
|
2021-09-26 03:14:49 +00:00
|
|
|
ExitCallback exit_callback;
|
2020-11-24 23:16:24 +00:00
|
|
|
|
2020-03-12 20:48:43 +00:00
|
|
|
std::array<u64, Core::Hardware::NUM_CPU_CORES> dynarmic_ticks{};
|
2020-04-12 23:25:53 +00:00
|
|
|
std::array<MicroProfileToken, Core::Hardware::NUM_CPU_CORES> microprofile_dynarmic{};
|
2018-08-30 14:50:54 +00:00
|
|
|
};
|
|
|
|
|
2019-03-05 17:28:10 +00:00
|
|
|
System::System() : impl{std::make_unique<Impl>(*this)} {}
|
2021-08-24 05:32:38 +00:00
|
|
|
|
2021-10-14 18:21:15 +00:00
|
|
|
System::~System() = default;
|
2021-08-13 18:39:45 +00:00
|
|
|
|
2020-02-25 02:04:12 +00:00
|
|
|
CpuManager& System::GetCpuManager() {
|
|
|
|
return impl->cpu_manager;
|
|
|
|
}
|
|
|
|
|
|
|
|
const CpuManager& System::GetCpuManager() const {
|
|
|
|
return impl->cpu_manager;
|
2018-08-30 14:50:54 +00:00
|
|
|
}
|
|
|
|
|
2022-09-10 08:48:15 +00:00
|
|
|
void System::Initialize() {
|
|
|
|
impl->Initialize(*this);
|
|
|
|
}
|
|
|
|
|
2021-10-14 22:14:40 +00:00
|
|
|
SystemResultStatus System::Run() {
|
2020-02-25 02:04:12 +00:00
|
|
|
return impl->Run();
|
2018-10-28 21:37:31 +00:00
|
|
|
}
|
|
|
|
|
2021-10-14 22:14:40 +00:00
|
|
|
SystemResultStatus System::Pause() {
|
2020-02-25 02:04:12 +00:00
|
|
|
return impl->Pause();
|
2018-08-30 14:50:54 +00:00
|
|
|
}
|
|
|
|
|
2022-07-16 22:48:45 +00:00
|
|
|
bool System::IsPaused() const {
|
|
|
|
return impl->IsPaused();
|
|
|
|
}
|
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
void System::InvalidateCpuInstructionCaches() {
|
2020-01-25 22:55:32 +00:00
|
|
|
impl->kernel.InvalidateAllInstructionCaches();
|
2018-08-30 14:50:54 +00:00
|
|
|
}
|
|
|
|
|
2020-11-14 07:20:32 +00:00
|
|
|
void System::InvalidateCpuInstructionCacheRange(VAddr addr, std::size_t size) {
|
|
|
|
impl->kernel.InvalidateCpuInstructionCacheRange(addr, size);
|
|
|
|
}
|
|
|
|
|
2022-09-10 08:48:15 +00:00
|
|
|
void System::ShutdownMainProcess() {
|
|
|
|
impl->ShutdownMainProcess();
|
2020-11-18 07:09:05 +00:00
|
|
|
}
|
|
|
|
|
2022-07-16 22:48:45 +00:00
|
|
|
bool System::IsShuttingDown() const {
|
|
|
|
return impl->IsShuttingDown();
|
|
|
|
}
|
|
|
|
|
|
|
|
void System::SetShuttingDown(bool shutting_down) {
|
|
|
|
impl->SetShuttingDown(shutting_down);
|
|
|
|
}
|
|
|
|
|
2022-06-10 13:17:12 +00:00
|
|
|
void System::DetachDebugger() {
|
|
|
|
if (impl->debugger) {
|
|
|
|
impl->debugger->NotifyShutdown();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-13 22:36:30 +00:00
|
|
|
std::unique_lock<std::mutex> System::StallProcesses() {
|
|
|
|
return impl->StallProcesses();
|
2021-10-15 22:20:19 +00:00
|
|
|
}
|
|
|
|
|
2022-06-13 22:36:30 +00:00
|
|
|
void System::UnstallProcesses() {
|
|
|
|
impl->UnstallProcesses();
|
2021-10-05 21:54:33 +00:00
|
|
|
}
|
|
|
|
|
2022-05-30 23:35:01 +00:00
|
|
|
void System::InitializeDebugger() {
|
|
|
|
impl->InitializeDebugger(*this, Settings::values.gdbstub_port.GetValue());
|
|
|
|
}
|
|
|
|
|
2021-10-14 22:14:40 +00:00
|
|
|
SystemResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath,
|
|
|
|
u64 program_id, std::size_t program_index) {
|
2021-07-20 05:10:05 +00:00
|
|
|
return impl->Load(*this, emu_window, filepath, program_id, program_index);
|
2018-08-30 14:50:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool System::IsPoweredOn() const {
|
2021-06-22 07:22:19 +00:00
|
|
|
return impl->is_powered_on.load(std::memory_order::relaxed);
|
2013-09-05 22:33:46 +00:00
|
|
|
}
|
|
|
|
|
2019-06-19 13:11:18 +00:00
|
|
|
void System::PrepareReschedule(const u32 core_index) {
|
2020-01-26 18:07:22 +00:00
|
|
|
impl->kernel.PrepareReschedule(core_index);
|
2019-04-02 13:22:53 +00:00
|
|
|
}
|
|
|
|
|
2018-08-31 16:21:34 +00:00
|
|
|
PerfStatsResults System::GetAndResetPerfStats() {
|
2018-08-30 14:50:54 +00:00
|
|
|
return impl->GetAndResetPerfStats();
|
2017-02-19 22:34:47 +00:00
|
|
|
}
|
|
|
|
|
2018-10-28 21:37:31 +00:00
|
|
|
TelemetrySession& System::TelemetrySession() {
|
|
|
|
return *impl->telemetry_session;
|
|
|
|
}
|
|
|
|
|
|
|
|
const TelemetrySession& System::TelemetrySession() const {
|
2018-08-30 14:50:54 +00:00
|
|
|
return *impl->telemetry_session;
|
2018-05-03 04:34:54 +00:00
|
|
|
}
|
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
ARM_Interface& System::CurrentArmInterface() {
|
2020-11-13 19:11:12 +00:00
|
|
|
return impl->kernel.CurrentPhysicalCore().ArmInterface();
|
2018-08-28 16:30:33 +00:00
|
|
|
}
|
|
|
|
|
2018-10-28 21:37:31 +00:00
|
|
|
const ARM_Interface& System::CurrentArmInterface() const {
|
2020-11-13 19:11:12 +00:00
|
|
|
return impl->kernel.CurrentPhysicalCore().ArmInterface();
|
2018-10-28 21:37:31 +00:00
|
|
|
}
|
|
|
|
|
2020-02-25 17:22:11 +00:00
|
|
|
Kernel::PhysicalCore& System::CurrentPhysicalCore() {
|
2020-03-01 16:14:17 +00:00
|
|
|
return impl->kernel.CurrentPhysicalCore();
|
2020-02-25 17:22:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const Kernel::PhysicalCore& System::CurrentPhysicalCore() const {
|
2020-03-01 16:14:17 +00:00
|
|
|
return impl->kernel.CurrentPhysicalCore();
|
2020-02-25 17:22:11 +00:00
|
|
|
}
|
|
|
|
|
2019-03-29 21:02:57 +00:00
|
|
|
/// Gets the global scheduler
|
2020-12-03 02:08:35 +00:00
|
|
|
Kernel::GlobalSchedulerContext& System::GlobalSchedulerContext() {
|
|
|
|
return impl->kernel.GlobalSchedulerContext();
|
2019-03-29 21:02:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Gets the global scheduler
|
2020-12-03 02:08:35 +00:00
|
|
|
const Kernel::GlobalSchedulerContext& System::GlobalSchedulerContext() const {
|
|
|
|
return impl->kernel.GlobalSchedulerContext();
|
2019-03-29 21:02:57 +00:00
|
|
|
}
|
|
|
|
|
2021-04-24 05:04:28 +00:00
|
|
|
Kernel::KProcess* System::CurrentProcess() {
|
2018-09-07 00:34:51 +00:00
|
|
|
return impl->kernel.CurrentProcess();
|
|
|
|
}
|
|
|
|
|
2020-04-08 23:18:10 +00:00
|
|
|
Core::DeviceMemory& System::DeviceMemory() {
|
2020-04-08 22:55:29 +00:00
|
|
|
return *impl->device_memory;
|
2020-04-03 02:00:41 +00:00
|
|
|
}
|
|
|
|
|
2020-04-08 23:18:10 +00:00
|
|
|
const Core::DeviceMemory& System::DeviceMemory() const {
|
2020-04-08 22:55:29 +00:00
|
|
|
return *impl->device_memory;
|
2020-04-03 02:00:41 +00:00
|
|
|
}
|
|
|
|
|
2021-04-24 05:04:28 +00:00
|
|
|
const Kernel::KProcess* System::CurrentProcess() const {
|
2018-09-07 00:34:51 +00:00
|
|
|
return impl->kernel.CurrentProcess();
|
2018-08-28 16:30:33 +00:00
|
|
|
}
|
|
|
|
|
2018-09-15 13:21:06 +00:00
|
|
|
ARM_Interface& System::ArmInterface(std::size_t core_index) {
|
2020-11-13 19:11:12 +00:00
|
|
|
return impl->kernel.PhysicalCore(core_index).ArmInterface();
|
2018-05-03 04:34:54 +00:00
|
|
|
}
|
|
|
|
|
2018-10-28 21:37:31 +00:00
|
|
|
const ARM_Interface& System::ArmInterface(std::size_t core_index) const {
|
2020-11-13 19:11:12 +00:00
|
|
|
return impl->kernel.PhysicalCore(core_index).ArmInterface();
|
2018-10-28 21:37:31 +00:00
|
|
|
}
|
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
ExclusiveMonitor& System::Monitor() {
|
2020-01-25 22:55:32 +00:00
|
|
|
return impl->kernel.GetExclusiveMonitor();
|
2018-10-28 21:37:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const ExclusiveMonitor& System::Monitor() const {
|
2020-01-25 22:55:32 +00:00
|
|
|
return impl->kernel.GetExclusiveMonitor();
|
2018-08-30 14:50:54 +00:00
|
|
|
}
|
2016-12-16 00:01:48 +00:00
|
|
|
|
2019-11-26 17:33:20 +00:00
|
|
|
Memory::Memory& System::Memory() {
|
|
|
|
return impl->memory;
|
|
|
|
}
|
|
|
|
|
2020-03-31 19:10:44 +00:00
|
|
|
const Core::Memory::Memory& System::Memory() const {
|
2019-11-26 17:33:20 +00:00
|
|
|
return impl->memory;
|
|
|
|
}
|
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
Tegra::GPU& System::GPU() {
|
|
|
|
return *impl->gpu_core;
|
|
|
|
}
|
2018-02-21 16:37:48 +00:00
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
const Tegra::GPU& System::GPU() const {
|
|
|
|
return *impl->gpu_core;
|
|
|
|
}
|
2018-08-03 15:51:48 +00:00
|
|
|
|
2022-01-30 09:31:13 +00:00
|
|
|
Tegra::Host1x::Host1x& System::Host1x() {
|
|
|
|
return *impl->host1x_core;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Tegra::Host1x::Host1x& System::Host1x() const {
|
|
|
|
return *impl->host1x_core;
|
|
|
|
}
|
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
VideoCore::RendererBase& System::Renderer() {
|
2020-03-25 02:58:49 +00:00
|
|
|
return impl->gpu_core->Renderer();
|
2018-08-30 14:50:54 +00:00
|
|
|
}
|
2018-03-13 21:49:59 +00:00
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
const VideoCore::RendererBase& System::Renderer() const {
|
2020-03-25 02:58:49 +00:00
|
|
|
return impl->gpu_core->Renderer();
|
2018-08-30 14:50:54 +00:00
|
|
|
}
|
2018-01-12 16:06:30 +00:00
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
Kernel::KernelCore& System::Kernel() {
|
|
|
|
return impl->kernel;
|
|
|
|
}
|
2018-04-20 23:29:04 +00:00
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
const Kernel::KernelCore& System::Kernel() const {
|
|
|
|
return impl->kernel;
|
|
|
|
}
|
2016-12-16 00:01:48 +00:00
|
|
|
|
2021-09-21 00:44:34 +00:00
|
|
|
HID::HIDCore& System::HIDCore() {
|
|
|
|
return impl->hid_core;
|
|
|
|
}
|
|
|
|
|
|
|
|
const HID::HIDCore& System::HIDCore() const {
|
|
|
|
return impl->hid_core;
|
|
|
|
}
|
|
|
|
|
2022-07-16 22:48:45 +00:00
|
|
|
AudioCore::AudioCore& System::AudioCore() {
|
|
|
|
return *impl->audio_core;
|
|
|
|
}
|
|
|
|
|
|
|
|
const AudioCore::AudioCore& System::AudioCore() const {
|
|
|
|
return *impl->audio_core;
|
|
|
|
}
|
|
|
|
|
2019-02-14 17:42:58 +00:00
|
|
|
Timing::CoreTiming& System::CoreTiming() {
|
|
|
|
return impl->core_timing;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Timing::CoreTiming& System::CoreTiming() const {
|
|
|
|
return impl->core_timing;
|
|
|
|
}
|
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
Core::PerfStats& System::GetPerfStats() {
|
2019-08-26 15:29:08 +00:00
|
|
|
return *impl->perf_stats;
|
2018-08-30 14:50:54 +00:00
|
|
|
}
|
2014-10-25 19:54:44 +00:00
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
const Core::PerfStats& System::GetPerfStats() const {
|
2019-08-26 15:29:08 +00:00
|
|
|
return *impl->perf_stats;
|
2018-08-30 14:50:54 +00:00
|
|
|
}
|
2018-08-03 16:55:58 +00:00
|
|
|
|
2021-07-22 23:56:21 +00:00
|
|
|
Core::SpeedLimiter& System::SpeedLimiter() {
|
|
|
|
return impl->speed_limiter;
|
2018-08-30 14:50:54 +00:00
|
|
|
}
|
2018-05-03 01:26:14 +00:00
|
|
|
|
2021-07-22 23:56:21 +00:00
|
|
|
const Core::SpeedLimiter& System::SpeedLimiter() const {
|
|
|
|
return impl->speed_limiter;
|
2018-08-30 14:50:54 +00:00
|
|
|
}
|
2016-12-16 00:01:48 +00:00
|
|
|
|
2021-11-04 00:32:26 +00:00
|
|
|
u64 System::GetCurrentProcessProgramID() const {
|
|
|
|
return impl->kernel.CurrentProcess()->GetProgramID();
|
|
|
|
}
|
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
Loader::ResultStatus System::GetGameName(std::string& out) const {
|
|
|
|
return impl->GetGameName(out);
|
|
|
|
}
|
2017-02-19 22:34:47 +00:00
|
|
|
|
2021-10-14 22:14:40 +00:00
|
|
|
void System::SetStatus(SystemResultStatus new_status, const char* details) {
|
2018-08-30 14:50:54 +00:00
|
|
|
impl->SetStatus(new_status, details);
|
2014-04-01 02:26:50 +00:00
|
|
|
}
|
|
|
|
|
2018-08-30 14:50:54 +00:00
|
|
|
const std::string& System::GetStatusDetails() const {
|
|
|
|
return impl->status_details;
|
|
|
|
}
|
2018-05-02 02:21:38 +00:00
|
|
|
|
2020-11-18 07:06:42 +00:00
|
|
|
Loader::AppLoader& System::GetAppLoader() {
|
|
|
|
return *impl->app_loader;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Loader::AppLoader& System::GetAppLoader() const {
|
2018-08-30 14:50:54 +00:00
|
|
|
return *impl->app_loader;
|
|
|
|
}
|
2018-02-21 16:37:48 +00:00
|
|
|
|
2020-09-16 22:14:43 +00:00
|
|
|
void System::SetFilesystem(FileSys::VirtualFilesystem vfs) {
|
2018-08-30 14:50:54 +00:00
|
|
|
impl->virtual_filesystem = std::move(vfs);
|
|
|
|
}
|
|
|
|
|
2020-09-16 22:14:43 +00:00
|
|
|
FileSys::VirtualFilesystem System::GetFilesystem() const {
|
2018-08-30 14:50:54 +00:00
|
|
|
return impl->virtual_filesystem;
|
|
|
|
}
|
|
|
|
|
2019-05-30 23:36:18 +00:00
|
|
|
void System::RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
|
|
|
|
const std::array<u8, 32>& build_id, VAddr main_region_begin,
|
|
|
|
u64 main_region_size) {
|
|
|
|
impl->cheat_engine = std::make_unique<Memory::CheatEngine>(*this, list, build_id);
|
|
|
|
impl->cheat_engine->SetMainMemoryParameters(main_region_begin, main_region_size);
|
|
|
|
}
|
|
|
|
|
2019-03-11 23:33:49 +00:00
|
|
|
void System::SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set) {
|
|
|
|
impl->applet_manager.SetAppletFrontendSet(std::move(set));
|
2018-11-23 02:00:04 +00:00
|
|
|
}
|
|
|
|
|
2019-03-11 23:33:49 +00:00
|
|
|
void System::SetDefaultAppletFrontendSet() {
|
|
|
|
impl->applet_manager.SetDefaultAppletFrontendSet();
|
2018-11-23 02:00:04 +00:00
|
|
|
}
|
|
|
|
|
2019-03-11 23:33:49 +00:00
|
|
|
Service::AM::Applets::AppletManager& System::GetAppletManager() {
|
|
|
|
return impl->applet_manager;
|
2018-11-11 21:39:25 +00:00
|
|
|
}
|
|
|
|
|
2019-03-11 23:33:49 +00:00
|
|
|
const Service::AM::Applets::AppletManager& System::GetAppletManager() const {
|
|
|
|
return impl->applet_manager;
|
2018-11-11 21:39:25 +00:00
|
|
|
}
|
|
|
|
|
2018-12-28 05:03:01 +00:00
|
|
|
void System::SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider) {
|
|
|
|
impl->content_provider = std::move(provider);
|
|
|
|
}
|
|
|
|
|
|
|
|
FileSys::ContentProvider& System::GetContentProvider() {
|
|
|
|
return *impl->content_provider;
|
|
|
|
}
|
|
|
|
|
|
|
|
const FileSys::ContentProvider& System::GetContentProvider() const {
|
|
|
|
return *impl->content_provider;
|
|
|
|
}
|
|
|
|
|
2019-04-23 12:35:33 +00:00
|
|
|
Service::FileSystem::FileSystemController& System::GetFileSystemController() {
|
|
|
|
return impl->fs_controller;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Service::FileSystem::FileSystemController& System::GetFileSystemController() const {
|
|
|
|
return impl->fs_controller;
|
|
|
|
}
|
|
|
|
|
2018-12-28 05:03:01 +00:00
|
|
|
void System::RegisterContentProvider(FileSys::ContentProviderUnionSlot slot,
|
|
|
|
FileSys::ContentProvider* provider) {
|
|
|
|
impl->content_provider->SetSlot(slot, provider);
|
|
|
|
}
|
|
|
|
|
|
|
|
void System::ClearContentProvider(FileSys::ContentProviderUnionSlot slot) {
|
|
|
|
impl->content_provider->ClearSlot(slot);
|
|
|
|
}
|
|
|
|
|
2019-05-18 01:45:56 +00:00
|
|
|
const Reporter& System::GetReporter() const {
|
|
|
|
return impl->reporter;
|
|
|
|
}
|
|
|
|
|
2019-06-24 23:27:35 +00:00
|
|
|
Service::Glue::ARPManager& System::GetARPManager() {
|
|
|
|
return impl->arp_manager;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Service::Glue::ARPManager& System::GetARPManager() const {
|
|
|
|
return impl->arp_manager;
|
|
|
|
}
|
|
|
|
|
2019-06-29 02:46:31 +00:00
|
|
|
Service::APM::Controller& System::GetAPMController() {
|
|
|
|
return impl->apm_controller;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Service::APM::Controller& System::GetAPMController() const {
|
|
|
|
return impl->apm_controller;
|
|
|
|
}
|
|
|
|
|
2020-10-13 01:09:15 +00:00
|
|
|
Service::Time::TimeManager& System::GetTimeManager() {
|
|
|
|
return impl->time_manager;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Service::Time::TimeManager& System::GetTimeManager() const {
|
|
|
|
return impl->time_manager;
|
|
|
|
}
|
|
|
|
|
2019-07-06 17:08:33 +00:00
|
|
|
void System::SetExitLock(bool locked) {
|
|
|
|
impl->exit_lock = locked;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool System::GetExitLock() const {
|
|
|
|
return impl->exit_lock;
|
|
|
|
}
|
|
|
|
|
2019-10-06 17:02:23 +00:00
|
|
|
void System::SetCurrentProcessBuildID(const CurrentBuildProcessID& id) {
|
2019-04-28 22:43:48 +00:00
|
|
|
impl->build_id = id;
|
|
|
|
}
|
|
|
|
|
2019-10-06 17:02:23 +00:00
|
|
|
const System::CurrentBuildProcessID& System::GetCurrentProcessBuildID() const {
|
2019-04-28 22:43:48 +00:00
|
|
|
return impl->build_id;
|
|
|
|
}
|
|
|
|
|
2018-04-20 23:29:04 +00:00
|
|
|
Service::SM::ServiceManager& System::ServiceManager() {
|
2018-08-30 14:50:54 +00:00
|
|
|
return *impl->service_manager;
|
2018-04-20 23:29:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const Service::SM::ServiceManager& System::ServiceManager() const {
|
2018-08-30 14:50:54 +00:00
|
|
|
return *impl->service_manager;
|
2018-04-20 23:29:04 +00:00
|
|
|
}
|
|
|
|
|
2020-02-22 15:13:07 +00:00
|
|
|
void System::RegisterCoreThread(std::size_t id) {
|
|
|
|
impl->kernel.RegisterCoreThread(id);
|
|
|
|
}
|
|
|
|
|
|
|
|
void System::RegisterHostThread() {
|
|
|
|
impl->kernel.RegisterHostThread();
|
|
|
|
}
|
|
|
|
|
2020-03-12 20:48:43 +00:00
|
|
|
void System::EnterDynarmicProfile() {
|
|
|
|
std::size_t core = impl->kernel.GetCurrentHostThreadID();
|
2020-04-12 23:25:53 +00:00
|
|
|
impl->dynarmic_ticks[core] = MicroProfileEnter(impl->microprofile_dynarmic[core]);
|
2020-03-12 20:48:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void System::ExitDynarmicProfile() {
|
|
|
|
std::size_t core = impl->kernel.GetCurrentHostThreadID();
|
2020-04-12 23:25:53 +00:00
|
|
|
MicroProfileLeave(impl->microprofile_dynarmic[core], impl->dynarmic_ticks[core]);
|
2020-03-12 20:48:43 +00:00
|
|
|
}
|
|
|
|
|
2020-05-29 19:00:17 +00:00
|
|
|
bool System::IsMulticore() const {
|
|
|
|
return impl->is_multicore;
|
|
|
|
}
|
|
|
|
|
2022-05-30 23:35:01 +00:00
|
|
|
bool System::DebuggerEnabled() const {
|
|
|
|
return Settings::values.use_gdbstub.GetValue();
|
|
|
|
}
|
|
|
|
|
|
|
|
Core::Debugger& System::GetDebugger() {
|
|
|
|
return *impl->debugger;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Core::Debugger& System::GetDebugger() const {
|
|
|
|
return *impl->debugger;
|
|
|
|
}
|
|
|
|
|
2022-07-22 14:31:13 +00:00
|
|
|
Network::RoomNetwork& System::GetRoomNetwork() {
|
|
|
|
return impl->room_network;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Network::RoomNetwork& System::GetRoomNetwork() const {
|
|
|
|
return impl->room_network;
|
|
|
|
}
|
|
|
|
|
2020-11-24 23:16:24 +00:00
|
|
|
void System::RegisterExecuteProgramCallback(ExecuteProgramCallback&& callback) {
|
|
|
|
impl->execute_program_callback = std::move(callback);
|
|
|
|
}
|
|
|
|
|
|
|
|
void System::ExecuteProgram(std::size_t program_index) {
|
|
|
|
if (impl->execute_program_callback) {
|
|
|
|
impl->execute_program_callback(program_index);
|
|
|
|
} else {
|
|
|
|
LOG_CRITICAL(Core, "execute_program_callback must be initialized by the frontend");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-26 03:14:49 +00:00
|
|
|
void System::RegisterExitCallback(ExitCallback&& callback) {
|
|
|
|
impl->exit_callback = std::move(callback);
|
|
|
|
}
|
|
|
|
|
|
|
|
void System::Exit() {
|
|
|
|
if (impl->exit_callback) {
|
|
|
|
impl->exit_callback();
|
|
|
|
} else {
|
|
|
|
LOG_CRITICAL(Core, "exit_callback must be initialized by the frontend");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-14 23:07:40 +00:00
|
|
|
void System::ApplySettings() {
|
|
|
|
if (IsPoweredOn()) {
|
|
|
|
Renderer().RefreshBaseSettings();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-26 23:17:47 +00:00
|
|
|
} // namespace Core
|