"Merge PR 1340"

2019-09-22 13:14:17 +00:00
88 changed files with 284 additions and 443 deletions
@@ -1066,7 +1066,7 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)

    RegisterHandlers(functions);

-    auto& kernel = system.Kernel();
+    auto& kernel = Core::System::GetInstance().Kernel();
    gpu_error_detected_event = Kernel::WritableEvent::CreateEventPair(
        kernel, Kernel::ResetType::Manual, "IApplicationFunctions:GpuErrorDetectedSystemEvent");
 }
@@ -29,9 +29,9 @@ static bool CheckAOCTitleIDMatchesBase(u64 title_id, u64 base) {
    return (title_id & DLC_BASE_TITLE_ID_MASK) == base;
 }

-static std::vector<u64> AccumulateAOCTitleIDs(Core::System& system) {
+static std::vector<u64> AccumulateAOCTitleIDs() {
    std::vector<u64> add_on_content;
-    const auto& rcu = system.GetContentProvider();
+    const auto& rcu = Core::System::GetInstance().GetContentProvider();
    const auto list =
        rcu.ListEntriesFilter(FileSys::TitleType::AOC, FileSys::ContentRecordType::Data);
    std::transform(list.begin(), list.end(), std::back_inserter(add_on_content),
@@ -47,8 +47,7 @@ static std::vector<u64> AccumulateAOCTitleIDs(Core::System& system) {
    return add_on_content;
 }

-AOC_U::AOC_U(Core::System& system)
-    : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs(system)), system(system) {
+AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs()) {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0, nullptr, "CountAddOnContentByApplicationId"},
@@ -66,7 +65,7 @@ AOC_U::AOC_U(Core::System& system)

    RegisterHandlers(functions);

-    auto& kernel = system.Kernel();
+    auto& kernel = Core::System::GetInstance().Kernel();
    aoc_change_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Manual,
                                                              "GetAddOnContentListChanged:Event");
 }
@@ -87,7 +86,7 @@ void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);

-    const auto current = system.CurrentProcess()->GetTitleID();
+    const auto current = Core::System::GetInstance().CurrentProcess()->GetTitleID();

    const auto& disabled = Settings::values.disabled_addons[current];
    if (std::find(disabled.begin(), disabled.end(), "DLC") != disabled.end()) {
@@ -114,7 +113,7 @@ void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_AOC, "called with offset={}, count={}, process_id={}", offset, count,
              process_id);

-    const auto current = system.CurrentProcess()->GetTitleID();
+    const auto current = Core::System::GetInstance().CurrentProcess()->GetTitleID();

    std::vector<u32> out;
    const auto& disabled = Settings::values.disabled_addons[current];
@@ -160,7 +159,7 @@ void AOC_U::GetAddOnContentBaseId(Kernel::HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(RESULT_SUCCESS);

-    const auto title_id = system.CurrentProcess()->GetTitleID();
+    const auto title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
    FileSys::PatchManager pm{title_id};

    const auto res = pm.GetControlMetadata();
@@ -197,8 +196,8 @@ void AOC_U::GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx) {
    rb.PushCopyObjects(aoc_change_event.readable);
 }

-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    std::make_shared<AOC_U>(system)->InstallAsService(service_manager);
+void InstallInterfaces(SM::ServiceManager& service_manager) {
+    std::make_shared<AOC_U>()->InstallAsService(service_manager);
 }

 } // namespace Service::AOC
@@ -14,7 +14,7 @@ namespace Service::AOC {

 class AOC_U final : public ServiceFramework<AOC_U> {
 public:
-    explicit AOC_U(Core::System& system);
+    AOC_U();
    ~AOC_U() override;

 private:
@@ -26,10 +26,9 @@ private:

    std::vector<u64> add_on_content;
    Kernel::EventPair aoc_change_event;
-    Core::System& system;
 };

 /// Registers all AOC services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager);

 } // namespace Service::AOC
@@ -16,7 +16,7 @@ namespace Service::BtDrv {

 class Bt final : public ServiceFramework<Bt> {
 public:
-    explicit Bt(Core::System& system) : ServiceFramework{"bt"} {
+    explicit Bt() : ServiceFramework{"bt"} {
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, nullptr, "LeClientReadCharacteristic"},
@@ -33,7 +33,7 @@ public:
        // clang-format on
        RegisterHandlers(functions);

-        auto& kernel = system.Kernel();
+        auto& kernel = Core::System::GetInstance().Kernel();
        register_event = Kernel::WritableEvent::CreateEventPair(
            kernel, Kernel::ResetType::Automatic, "BT:RegisterEvent");
    }
@@ -163,9 +163,9 @@ public:
    }
 };

-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
+void InstallInterfaces(SM::ServiceManager& sm) {
    std::make_shared<BtDrv>()->InstallAsService(sm);
-    std::make_shared<Bt>(system)->InstallAsService(sm);
+    std::make_shared<Bt>()->InstallAsService(sm);
 }

 } // namespace Service::BtDrv
@@ -8,13 +8,9 @@ namespace Service::SM {
 class ServiceManager;
 }

-namespace Core {
-class System;
-}
-
 namespace Service::BtDrv {

 /// Registers all BtDrv services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void InstallInterfaces(SM::ServiceManager& sm);

 } // namespace Service::BtDrv
@@ -17,7 +17,7 @@ namespace Service::BTM {

 class IBtmUserCore final : public ServiceFramework<IBtmUserCore> {
 public:
-    explicit IBtmUserCore(Core::System& system) : ServiceFramework{"IBtmUserCore"} {
+    explicit IBtmUserCore() : ServiceFramework{"IBtmUserCore"} {
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, &IBtmUserCore::AcquireBleScanEvent, "AcquireBleScanEvent"},
@@ -56,7 +56,7 @@ public:
        // clang-format on
        RegisterHandlers(functions);

-        auto& kernel = system.Kernel();
+        auto& kernel = Core::System::GetInstance().Kernel();
        scan_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Automatic,
                                                            "IBtmUserCore:ScanEvent");
        connection_event = Kernel::WritableEvent::CreateEventPair(
@@ -108,7 +108,7 @@ private:

 class BTM_USR final : public ServiceFramework<BTM_USR> {
 public:
-    explicit BTM_USR(Core::System& system) : ServiceFramework{"btm:u"}, system(system) {
+    explicit BTM_USR() : ServiceFramework{"btm:u"} {
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, &BTM_USR::GetCore, "GetCore"},
@@ -123,10 +123,8 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IBtmUserCore>(system);
+        rb.PushIpcInterface<IBtmUserCore>();
    }
-
-    Core::System& system;
 };

 class BTM final : public ServiceFramework<BTM> {
@@ -270,11 +268,11 @@ private:
    }
 };

-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
+void InstallInterfaces(SM::ServiceManager& sm) {
    std::make_shared<BTM>()->InstallAsService(sm);
    std::make_shared<BTM_DBG>()->InstallAsService(sm);
    std::make_shared<BTM_SYS>()->InstallAsService(sm);
-    std::make_shared<BTM_USR>(system)->InstallAsService(sm);
+    std::make_shared<BTM_USR>()->InstallAsService(sm);
 }

 } // namespace Service::BTM
@@ -8,12 +8,8 @@ namespace Service::SM {
 class ServiceManager;
 }

-namespace Core {
-class System;
-};
-
 namespace Service::BTM {

-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void InstallInterfaces(SM::ServiceManager& sm);

 } // namespace Service::BTM
@@ -20,8 +20,8 @@

 namespace Service::Fatal {

-Module::Interface::Interface(std::shared_ptr<Module> module, Core::System& system, const char* name)
-    : ServiceFramework(name), module(std::move(module)), system(system) {}
+Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
+    : ServiceFramework(name), module(std::move(module)) {}

 Module::Interface::~Interface() = default;

@@ -64,8 +64,7 @@ enum class FatalType : u32 {
    ErrorScreen = 2,
 };

-static void GenerateErrorReport(Core::System& system, ResultCode error_code,
-                                const FatalInfo& info) {
+static void GenerateErrorReport(ResultCode error_code, const FatalInfo& info) {
    const auto title_id = Core::CurrentProcess()->GetTitleID();
    std::string crash_report = fmt::format(
        "Yuzu {}-{} crash report\n"
@@ -102,19 +101,18 @@ static void GenerateErrorReport(Core::System& system, ResultCode error_code,

    LOG_ERROR(Service_Fatal, "{}", crash_report);

-    system.GetReporter().SaveCrashReport(
+    Core::System::GetInstance().GetReporter().SaveCrashReport(
        title_id, error_code, info.set_flags, info.program_entry_point, info.sp, info.pc,
        info.pstate, info.afsr0, info.afsr1, info.esr, info.far, info.registers, info.backtrace,
        info.backtrace_size, info.ArchAsString(), info.unk10);
 }

-static void ThrowFatalError(Core::System& system, ResultCode error_code, FatalType fatal_type,
-                            const FatalInfo& info) {
+static void ThrowFatalError(ResultCode error_code, FatalType fatal_type, const FatalInfo& info) {
    LOG_ERROR(Service_Fatal, "Threw fatal error type {} with error code 0x{:X}",
              static_cast<u32>(fatal_type), error_code.raw);
    switch (fatal_type) {
    case FatalType::ErrorReportAndScreen:
-        GenerateErrorReport(system, error_code, info);
+        GenerateErrorReport(error_code, info);
        [[fallthrough]];
    case FatalType::ErrorScreen:
        // Since we have no fatal:u error screen. We should just kill execution instead
@@ -122,7 +120,7 @@ static void ThrowFatalError(Core::System& system, ResultCode error_code, FatalTy
        break;
        // Should not throw a fatal screen but should generate an error report
    case FatalType::ErrorReport:
-        GenerateErrorReport(system, error_code, info);
+        GenerateErrorReport(error_code, info);
        break;
    }
 }
@@ -132,7 +130,7 @@ void Module::Interface::ThrowFatal(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto error_code = rp.Pop<ResultCode>();

-    ThrowFatalError(system, error_code, FatalType::ErrorScreen, {});
+    ThrowFatalError(error_code, FatalType::ErrorScreen, {});
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
@@ -143,8 +141,7 @@ void Module::Interface::ThrowFatalWithPolicy(Kernel::HLERequestContext& ctx) {
    const auto error_code = rp.Pop<ResultCode>();
    const auto fatal_type = rp.PopEnum<FatalType>();

-    ThrowFatalError(system, error_code, fatal_type,
-                    {}); // No info is passed with ThrowFatalWithPolicy
+    ThrowFatalError(error_code, fatal_type, {}); // No info is passed with ThrowFatalWithPolicy
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }
@@ -160,15 +157,15 @@ void Module::Interface::ThrowFatalWithCpuContext(Kernel::HLERequestContext& ctx)
    ASSERT_MSG(fatal_info.size() == sizeof(FatalInfo), "Invalid fatal info buffer size!");
    std::memcpy(&info, fatal_info.data(), sizeof(FatalInfo));

-    ThrowFatalError(system, error_code, fatal_type, info);
+    ThrowFatalError(error_code, fatal_type, info);
    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }

-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
+void InstallInterfaces(SM::ServiceManager& service_manager) {
    auto module = std::make_shared<Module>();
-    std::make_shared<Fatal_P>(module, system)->InstallAsService(service_manager);
-    std::make_shared<Fatal_U>(module, system)->InstallAsService(service_manager);
+    std::make_shared<Fatal_P>(module)->InstallAsService(service_manager);
+    std::make_shared<Fatal_U>(module)->InstallAsService(service_manager);
 }

 } // namespace Service::Fatal
@@ -6,17 +6,13 @@

 #include "core/hle/service/service.h"

-namespace Core {
-class System;
-}
-
 namespace Service::Fatal {

 class Module final {
 public:
    class Interface : public ServiceFramework<Interface> {
    public:
-        explicit Interface(std::shared_ptr<Module> module, Core::System& system, const char* name);
+        explicit Interface(std::shared_ptr<Module> module, const char* name);
        ~Interface() override;

        void ThrowFatal(Kernel::HLERequestContext& ctx);
@@ -25,10 +21,9 @@ public:

    protected:
        std::shared_ptr<Module> module;
-        Core::System& system;
    };
 };

-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager);

 } // namespace Service::Fatal
@@ -6,8 +6,8 @@

 namespace Service::Fatal {

-Fatal_P::Fatal_P(std::shared_ptr<Module> module, Core::System& system)
-    : Module::Interface(std::move(module), system, "fatal:p") {}
+Fatal_P::Fatal_P(std::shared_ptr<Module> module)
+    : Module::Interface(std::move(module), "fatal:p") {}

 Fatal_P::~Fatal_P() = default;

@@ -10,7 +10,7 @@ namespace Service::Fatal {

 class Fatal_P final : public Module::Interface {
 public:
-    explicit Fatal_P(std::shared_ptr<Module> module, Core::System& system);
+    explicit Fatal_P(std::shared_ptr<Module> module);
    ~Fatal_P() override;
 };

@@ -6,8 +6,7 @@

 namespace Service::Fatal {

-Fatal_U::Fatal_U(std::shared_ptr<Module> module, Core::System& system)
-    : Module::Interface(std::move(module), system, "fatal:u") {
+Fatal_U::Fatal_U(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "fatal:u") {
    static const FunctionInfo functions[] = {
        {0, &Fatal_U::ThrowFatal, "ThrowFatal"},
        {1, &Fatal_U::ThrowFatalWithPolicy, "ThrowFatalWithPolicy"},
@@ -10,7 +10,7 @@ namespace Service::Fatal {

 class Fatal_U final : public Module::Interface {
 public:
-    explicit Fatal_U(std::shared_ptr<Module> module, Core::System& system);
+    explicit Fatal_U(std::shared_ptr<Module> module);
    ~Fatal_U() override;
 };

@@ -149,8 +149,7 @@ private:

 class INotificationService final : public ServiceFramework<INotificationService> {
 public:
-    INotificationService(Common::UUID uuid, Core::System& system)
-        : ServiceFramework("INotificationService"), uuid(uuid) {
+    INotificationService(Common::UUID uuid) : ServiceFramework("INotificationService"), uuid(uuid) {
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, &INotificationService::GetEvent, "GetEvent"},
@@ -160,9 +159,6 @@ public:
        // clang-format on

        RegisterHandlers(functions);
-
-        notification_event = Kernel::WritableEvent::CreateEventPair(
-            system.Kernel(), Kernel::ResetType::Manual, "INotificationService:NotifyEvent");
    }

 private:
@@ -171,6 +167,13 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
+
+        if (!is_event_created) {
+            auto& kernel = Core::System::GetInstance().Kernel();
+            notification_event = Kernel::WritableEvent::CreateEventPair(
+                kernel, Kernel::ResetType::Manual, "INotificationService:NotifyEvent");
+            is_event_created = true;
+        }
        rb.PushCopyObjects(notification_event.readable);
    }

@@ -258,21 +261,21 @@ void Module::Interface::CreateNotificationService(Kernel::HLERequestContext& ctx

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<INotificationService>(uuid, system);
+    rb.PushIpcInterface<INotificationService>(uuid);
 }

-Module::Interface::Interface(std::shared_ptr<Module> module, Core::System& system, const char* name)
-    : ServiceFramework(name), module(std::move(module)), system(system) {}
+Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
+    : ServiceFramework(name), module(std::move(module)) {}

 Module::Interface::~Interface() = default;

-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
+void InstallInterfaces(SM::ServiceManager& service_manager) {
    auto module = std::make_shared<Module>();
-    std::make_shared<Friend>(module, system, "friend:a")->InstallAsService(service_manager);
-    std::make_shared<Friend>(module, system, "friend:m")->InstallAsService(service_manager);
-    std::make_shared<Friend>(module, system, "friend:s")->InstallAsService(service_manager);
-    std::make_shared<Friend>(module, system, "friend:u")->InstallAsService(service_manager);
-    std::make_shared<Friend>(module, system, "friend:v")->InstallAsService(service_manager);
+    std::make_shared<Friend>(module, "friend:a")->InstallAsService(service_manager);
+    std::make_shared<Friend>(module, "friend:m")->InstallAsService(service_manager);
+    std::make_shared<Friend>(module, "friend:s")->InstallAsService(service_manager);
+    std::make_shared<Friend>(module, "friend:u")->InstallAsService(service_manager);
+    std::make_shared<Friend>(module, "friend:v")->InstallAsService(service_manager);
 }

 } // namespace Service::Friend
@@ -6,17 +6,13 @@

 #include "core/hle/service/service.h"

-namespace Core {
-class System;
-}
-
 namespace Service::Friend {

 class Module final {
 public:
    class Interface : public ServiceFramework<Interface> {
    public:
-        explicit Interface(std::shared_ptr<Module> module, Core::System& system, const char* name);
+        explicit Interface(std::shared_ptr<Module> module, const char* name);
        ~Interface() override;

        void CreateFriendService(Kernel::HLERequestContext& ctx);
@@ -24,11 +20,10 @@ public:

    protected:
        std::shared_ptr<Module> module;
-        Core::System& system;
    };
 };

 /// Registers all Friend services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager);

 } // namespace Service::Friend
@@ -6,8 +6,8 @@

 namespace Service::Friend {

-Friend::Friend(std::shared_ptr<Module> module, Core::System& system, const char* name)
-    : Interface(std::move(module), system, name) {
+Friend::Friend(std::shared_ptr<Module> module, const char* name)
+    : Interface(std::move(module), name) {
    static const FunctionInfo functions[] = {
        {0, &Friend::CreateFriendService, "CreateFriendService"},
        {1, &Friend::CreateNotificationService, "CreateNotificationService"},
@@ -10,7 +10,7 @@ namespace Service::Friend {

 class Friend final : public Module::Interface {
 public:
-    explicit Friend(std::shared_ptr<Module> module, Core::System& system, const char* name);
+    explicit Friend(std::shared_ptr<Module> module, const char* name);
    ~Friend() override;
 };

@@ -6,7 +6,7 @@

 namespace Service::HID {

-ControllerBase::ControllerBase(Core::System& system) : system(system) {}
+ControllerBase::ControllerBase() = default;
 ControllerBase::~ControllerBase() = default;

 void ControllerBase::ActivateController() {
@@ -11,14 +11,10 @@ namespace Core::Timing {
 class CoreTiming;
 }

-namespace Core {
-class System;
-}
-
 namespace Service::HID {
 class ControllerBase {
 public:
-    explicit ControllerBase(Core::System& system);
+    ControllerBase();
    virtual ~ControllerBase();

    // Called when the controller is initialized
@@ -50,7 +46,5 @@ protected:
        s64_le entry_count;
    };
    static_assert(sizeof(CommonHeader) == 0x20, "CommonHeader is an invalid size");
-
-    Core::System& system;
 };
 } // namespace Service::HID
@@ -14,8 +14,7 @@ constexpr s32 HID_JOYSTICK_MAX = 0x7fff;
 constexpr s32 HID_JOYSTICK_MIN = -0x7fff;
 enum class JoystickId : std::size_t { Joystick_Left, Joystick_Right };

-Controller_DebugPad::Controller_DebugPad(Core::System& system)
-    : ControllerBase(system), system(system) {}
+Controller_DebugPad::Controller_DebugPad() = default;
 Controller_DebugPad::~Controller_DebugPad() = default;

 void Controller_DebugPad::OnInit() {}
@@ -16,7 +16,7 @@
 namespace Service::HID {
 class Controller_DebugPad final : public ControllerBase {
 public:
-    explicit Controller_DebugPad(Core::System& system);
+    Controller_DebugPad();
    ~Controller_DebugPad() override;

    // Called when the controller is initialized
@@ -89,6 +89,5 @@ private:
        buttons;
    std::array<std::unique_ptr<Input::AnalogDevice>, Settings::NativeAnalog::NUM_STICKS_HID>
        analogs;
-    Core::System& system;
 };
 } // namespace Service::HID
@@ -10,8 +10,7 @@
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3BA00;

-Controller_Gesture::Controller_Gesture(Core::System& system)
-    : ControllerBase(system), system(system) {}
+Controller_Gesture::Controller_Gesture() = default;
 Controller_Gesture::~Controller_Gesture() = default;

 void Controller_Gesture::OnInit() {}
@@ -12,7 +12,7 @@
 namespace Service::HID {
 class Controller_Gesture final : public ControllerBase {
 public:
-    explicit Controller_Gesture(Core::System& system);
+    Controller_Gesture();
    ~Controller_Gesture() override;

    // Called when the controller is initialized
@@ -59,6 +59,5 @@ private:
        std::array<GestureState, 17> gesture_states;
    };
    SharedMemory shared_memory{};
-    Core::System& system;
 };
 } // namespace Service::HID
@@ -12,8 +12,7 @@ namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3800;
 constexpr u8 KEYS_PER_BYTE = 8;

-Controller_Keyboard::Controller_Keyboard(Core::System& system)
-    : ControllerBase(system), system(system) {}
+Controller_Keyboard::Controller_Keyboard() = default;
 Controller_Keyboard::~Controller_Keyboard() = default;

 void Controller_Keyboard::OnInit() {}
@@ -15,7 +15,7 @@
 namespace Service::HID {
 class Controller_Keyboard final : public ControllerBase {
 public:
-    explicit Controller_Keyboard(Core::System& system);
+    Controller_Keyboard();
    ~Controller_Keyboard() override;

    // Called when the controller is initialized
@@ -53,6 +53,5 @@ private:
        keyboard_keys;
    std::array<std::unique_ptr<Input::ButtonDevice>, Settings::NativeKeyboard::NumKeyboardMods>
        keyboard_mods;
-    Core::System& system;
 };
 } // namespace Service::HID
@@ -11,7 +11,7 @@
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3400;

-Controller_Mouse::Controller_Mouse(Core::System& system) : ControllerBase(system), system(system) {}
+Controller_Mouse::Controller_Mouse() = default;
 Controller_Mouse::~Controller_Mouse() = default;

 void Controller_Mouse::OnInit() {}
@@ -14,7 +14,7 @@
 namespace Service::HID {
 class Controller_Mouse final : public ControllerBase {
 public:
-    explicit Controller_Mouse(Core::System& system);
+    Controller_Mouse();
    ~Controller_Mouse() override;

    // Called when the controller is initialized
@@ -53,6 +53,5 @@ private:
    std::unique_ptr<Input::MouseDevice> mouse_device;
    std::array<std::unique_ptr<Input::ButtonDevice>, Settings::NativeMouseButton::NumMouseButtons>
        mouse_button_devices;
-    Core::System& system;
 };
 } // namespace Service::HID
@@ -93,7 +93,7 @@ u32 Controller_NPad::IndexToNPad(std::size_t index) {
    };
 }

-Controller_NPad::Controller_NPad(Core::System& system) : ControllerBase(system), system(system) {}
+Controller_NPad::Controller_NPad() = default;
 Controller_NPad::~Controller_NPad() = default;

 void Controller_NPad::InitNewlyAddedControler(std::size_t controller_idx) {
@@ -168,7 +168,7 @@ void Controller_NPad::InitNewlyAddedControler(std::size_t controller_idx) {
 }

 void Controller_NPad::OnInit() {
-    auto& kernel = system.Kernel();
+    auto& kernel = Core::System::GetInstance().Kernel();
    styleset_changed_event = Kernel::WritableEvent::CreateEventPair(
        kernel, Kernel::ResetType::Automatic, "npad:NpadStyleSetChanged");

@@ -20,7 +20,7 @@ constexpr u32 NPAD_UNKNOWN = 16; // TODO(ogniK): What is this?

 class Controller_NPad final : public ControllerBase {
 public:
-    explicit Controller_NPad(Core::System& system);
+    Controller_NPad();
    ~Controller_NPad() override;

    // Called when the controller is initialized
@@ -327,6 +327,5 @@ private:
    std::array<ControllerPad, 10> npad_pad_states{};
    bool IsControllerSupported(NPadControllerType controller);
    bool is_in_lr_assignment_mode{false};
-    Core::System& system;
 };
 } // namespace Service::HID
@@ -9,8 +9,7 @@

 namespace Service::HID {

-Controller_Stubbed::Controller_Stubbed(Core::System& system)
-    : ControllerBase(system), system(system) {}
+Controller_Stubbed::Controller_Stubbed() = default;
 Controller_Stubbed::~Controller_Stubbed() = default;

 void Controller_Stubbed::OnInit() {}
@@ -10,7 +10,7 @@
 namespace Service::HID {
 class Controller_Stubbed final : public ControllerBase {
 public:
-    explicit Controller_Stubbed(Core::System& system);
+    Controller_Stubbed();
    ~Controller_Stubbed() override;

    // Called when the controller is initialized
@@ -30,6 +30,5 @@ public:
 private:
    bool smart_update{};
    std::size_t common_offset{};
-    Core::System& system;
 };
 } // namespace Service::HID
@@ -13,8 +13,7 @@
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x400;

-Controller_Touchscreen::Controller_Touchscreen(Core::System& system)
-    : ControllerBase(system), system(system) {}
+Controller_Touchscreen::Controller_Touchscreen() = default;
 Controller_Touchscreen::~Controller_Touchscreen() = default;

 void Controller_Touchscreen::OnInit() {}
@@ -14,7 +14,7 @@
 namespace Service::HID {
 class Controller_Touchscreen final : public ControllerBase {
 public:
-    explicit Controller_Touchscreen(Core::System& system);
+    Controller_Touchscreen();
    ~Controller_Touchscreen() override;

    // Called when the controller is initialized
@@ -69,6 +69,5 @@ private:
    TouchScreenSharedMemory shared_memory{};
    std::unique_ptr<Input::TouchDevice> touch_device;
    s64_le last_touch{};
-    Core::System& system;
 };
 } // namespace Service::HID
@@ -10,7 +10,7 @@
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3C00;

-Controller_XPad::Controller_XPad(Core::System& system) : ControllerBase(system), system(system) {}
+Controller_XPad::Controller_XPad() = default;
 Controller_XPad::~Controller_XPad() = default;

 void Controller_XPad::OnInit() {}
@@ -12,7 +12,7 @@
 namespace Service::HID {
 class Controller_XPad final : public ControllerBase {
 public:
-    explicit Controller_XPad(Core::System& system);
+    Controller_XPad();
    ~Controller_XPad() override;

    // Called when the controller is initialized
@@ -56,6 +56,5 @@ private:
    };
    static_assert(sizeof(SharedMemory) == 0x1000, "SharedMemory is an invalid size");
    SharedMemory shared_memory{};
-    Core::System& system;
 };
 } // namespace Service::HID
@@ -42,14 +42,13 @@ constexpr s64 accelerometer_update_ticks = static_cast<s64>(Core::Timing::BASE_C
 constexpr s64 gyroscope_update_ticks = static_cast<s64>(Core::Timing::BASE_CLOCK_RATE / 100);
 constexpr std::size_t SHARED_MEMORY_SIZE = 0x40000;

-IAppletResource::IAppletResource(Core::System& system)
-    : ServiceFramework("IAppletResource"), system(system) {
+IAppletResource::IAppletResource() : ServiceFramework("IAppletResource") {
    static const FunctionInfo functions[] = {
        {0, &IAppletResource::GetSharedMemoryHandle, "GetSharedMemoryHandle"},
    };
    RegisterHandlers(functions);

-    auto& kernel = system.Kernel();
+    auto& kernel = Core::System::GetInstance().Kernel();
    shared_mem = Kernel::SharedMemory::Create(
        kernel, nullptr, SHARED_MEMORY_SIZE, Kernel::MemoryPermission::ReadWrite,
        Kernel::MemoryPermission::Read, 0, Kernel::MemoryRegion::BASE, "HID:SharedMemory");
@@ -75,7 +74,7 @@ IAppletResource::IAppletResource(Core::System& system)
    GetController<Controller_Stubbed>(HidController::Unknown3).SetCommonHeaderOffset(0x5000);

    // Register update callbacks
-    auto& core_timing = system.CoreTiming();
+    auto& core_timing = Core::System::GetInstance().CoreTiming();
    pad_update_event =
        core_timing.RegisterEvent("HID::UpdatePadCallback", [this](u64 userdata, s64 cycles_late) {
            UpdateControllers(userdata, cycles_late);
@@ -97,7 +96,7 @@ void IAppletResource::DeactivateController(HidController controller) {
 }

 IAppletResource ::~IAppletResource() {
-    system.CoreTiming().UnscheduleEvent(pad_update_event, 0);
+    Core::System::GetInstance().CoreTiming().UnscheduleEvent(pad_update_event, 0);
 }

 void IAppletResource::GetSharedMemoryHandle(Kernel::HLERequestContext& ctx) {
@@ -109,7 +108,7 @@ void IAppletResource::GetSharedMemoryHandle(Kernel::HLERequestContext& ctx) {
 }

 void IAppletResource::UpdateControllers(u64 userdata, s64 cycles_late) {
-    auto& core_timing = system.CoreTiming();
+    auto& core_timing = Core::System::GetInstance().CoreTiming();

    const bool should_reload = Settings::values.is_device_reload_pending.exchange(false);
    for (const auto& controller : controllers) {
@@ -142,13 +141,13 @@ private:

 std::shared_ptr<IAppletResource> Hid::GetAppletResource() {
    if (applet_resource == nullptr) {
-        applet_resource = std::make_shared<IAppletResource>(system);
+        applet_resource = std::make_shared<IAppletResource>();
    }

    return applet_resource;
 }

-Hid::Hid(Core::System& system) : ServiceFramework("hid"), system(system) {
+Hid::Hid() : ServiceFramework("hid") {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0, &Hid::CreateAppletResource, "CreateAppletResource"},
@@ -287,7 +286,7 @@ void Hid::CreateAppletResource(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);

    if (applet_resource == nullptr) {
-        applet_resource = std::make_shared<IAppletResource>(system);
+        applet_resource = std::make_shared<IAppletResource>();
    }

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
@@ -1054,14 +1053,14 @@ void ReloadInputDevices() {
    Settings::values.is_device_reload_pending.store(true);
 }

-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    std::make_shared<Hid>(system)->InstallAsService(service_manager);
+void InstallInterfaces(SM::ServiceManager& service_manager) {
+    std::make_shared<Hid>()->InstallAsService(service_manager);
    std::make_shared<HidBus>()->InstallAsService(service_manager);
    std::make_shared<HidDbg>()->InstallAsService(service_manager);
    std::make_shared<HidSys>()->InstallAsService(service_manager);
    std::make_shared<HidTmp>()->InstallAsService(service_manager);

-    std::make_shared<IRS>(system)->InstallAsService(service_manager);
+    std::make_shared<IRS>()->InstallAsService(service_manager);
    std::make_shared<IRS_SYS>()->InstallAsService(service_manager);

    std::make_shared<XCD_SYS>()->InstallAsService(service_manager);
@@ -42,7 +42,7 @@ enum class HidController : std::size_t {

 class IAppletResource final : public ServiceFramework<IAppletResource> {
 public:
-    explicit IAppletResource(Core::System& system);
+    IAppletResource();
    ~IAppletResource() override;

    void ActivateController(HidController controller);
@@ -61,7 +61,7 @@ public:
 private:
    template <typename T>
    void MakeController(HidController controller) {
-        controllers[static_cast<std::size_t>(controller)] = std::make_unique<T>(system);
+        controllers[static_cast<std::size_t>(controller)] = std::make_unique<T>();
    }

    void GetSharedMemoryHandle(Kernel::HLERequestContext& ctx);
@@ -70,7 +70,6 @@ private:
    Kernel::SharedPtr<Kernel::SharedMemory> shared_mem;

    Core::Timing::EventType* pad_update_event;
-    Core::System& system;

    std::array<std::unique_ptr<ControllerBase>, static_cast<size_t>(HidController::MaxControllers)>
        controllers{};
@@ -78,7 +77,7 @@ private:

 class Hid final : public ServiceFramework<Hid> {
 public:
-    explicit Hid(Core::System& system);
+    Hid();
    ~Hid() override;

    std::shared_ptr<IAppletResource> GetAppletResource();
@@ -127,13 +126,12 @@ private:
    void SwapNpadAssignment(Kernel::HLERequestContext& ctx);

    std::shared_ptr<IAppletResource> applet_resource;
-    Core::System& system;
 };

 /// Reload input devices. Used when input configuration changed
 void ReloadInputDevices();

 /// Registers all HID services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager);

 } // namespace Service::HID
@@ -11,7 +11,7 @@

 namespace Service::HID {

-IRS::IRS(Core::System& system) : ServiceFramework{"irs"}, system(system) {
+IRS::IRS() : ServiceFramework{"irs"} {
    // clang-format off
    static const FunctionInfo functions[] = {
        {302, &IRS::ActivateIrsensor, "ActivateIrsensor"},
@@ -37,7 +37,7 @@ IRS::IRS(Core::System& system) : ServiceFramework{"irs"}, system(system) {

    RegisterHandlers(functions);

-    auto& kernel = system.Kernel();
+    auto& kernel = Core::System::GetInstance().Kernel();
    shared_mem = Kernel::SharedMemory::Create(
        kernel, nullptr, 0x8000, Kernel::MemoryPermission::ReadWrite,
        Kernel::MemoryPermission::Read, 0, Kernel::MemoryRegion::BASE, "IRS:SharedMemory");
@@ -98,7 +98,7 @@ void IRS::GetImageTransferProcessorState(Kernel::HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 5};
    rb.Push(RESULT_SUCCESS);
-    rb.PushRaw<u64>(system.CoreTiming().GetTicks());
+    rb.PushRaw<u64>(Core::System::GetInstance().CoreTiming().GetTicks());
    rb.PushRaw<u32>(0);
 }

@@ -15,7 +15,7 @@ namespace Service::HID {

 class IRS final : public ServiceFramework<IRS> {
 public:
-    explicit IRS(Core::System& system);
+    explicit IRS();
    ~IRS() override;

 private:
@@ -39,7 +39,6 @@ private:
    void ActivateIrsensorWithFunctionLevel(Kernel::HLERequestContext& ctx);
    Kernel::SharedPtr<Kernel::SharedMemory> shared_mem;
    const u32 device_handle{0xABCD};
-    Core::System& system;
 };

 class IRS_SYS final : public ServiceFramework<IRS_SYS> {
@@ -78,7 +78,7 @@ public:

 class RelocatableObject final : public ServiceFramework<RelocatableObject> {
 public:
-    explicit RelocatableObject(Core::System& system) : ServiceFramework{"ldr:ro"}, system(system) {
+    explicit RelocatableObject() : ServiceFramework{"ldr:ro"} {
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, &RelocatableObject::LoadNro, "LoadNro"},
@@ -364,7 +364,7 @@ public:
        vm_manager.ReprotectRange(*map_address + header.rw_offset, header.rw_size,
                                  Kernel::VMAPermission::ReadWrite);

-        system.InvalidateCpuInstructionCaches();
+        Core::System::GetInstance().InvalidateCpuInstructionCaches();

        nro.insert_or_assign(*map_address,
                             NROInfo{hash, nro_address, nro_size, bss_address, bss_size});
@@ -430,7 +430,7 @@ public:
                       .IsSuccess());
        }

-        system.InvalidateCpuInstructionCaches();
+        Core::System::GetInstance().InvalidateCpuInstructionCaches();

        nro.erase(iter);
        IPC::ResponseBuilder rb{ctx, 2};
@@ -516,14 +516,13 @@ private:
               Common::Is4KBAligned(header.text_size) && Common::Is4KBAligned(header.ro_size) &&
               Common::Is4KBAligned(header.rw_size);
    }
-    Core::System& system;
 };

-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
+void InstallInterfaces(SM::ServiceManager& sm) {
    std::make_shared<DebugMonitor>()->InstallAsService(sm);
    std::make_shared<ProcessManager>()->InstallAsService(sm);
    std::make_shared<Shell>()->InstallAsService(sm);
-    std::make_shared<RelocatableObject>(system)->InstallAsService(sm);
+    std::make_shared<RelocatableObject>()->InstallAsService(sm);
 }

 } // namespace Service::LDR
@@ -11,6 +11,6 @@ class ServiceManager;
 namespace Service::LDR {

 /// Registers all LDR services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void InstallInterfaces(SM::ServiceManager& sm);

 } // namespace Service::LDR
@@ -23,9 +23,9 @@ constexpr ResultCode ERR_TAG_FAILED(ErrorModule::NFP,
 constexpr ResultCode ERR_NO_APPLICATION_AREA(ErrorModule::NFP, 152);
 } // namespace ErrCodes

-Module::Interface::Interface(std::shared_ptr<Module> module, Core::System& system, const char* name)
-    : ServiceFramework(name), module(std::move(module)), system(system) {
-    auto& kernel = system.Kernel();
+Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
+    : ServiceFramework(name), module(std::move(module)) {
+    auto& kernel = Core::System::GetInstance().Kernel();
    nfc_tag_load = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Automatic,
                                                          "IUser:NFCTagDetected");
 }
@@ -34,8 +34,8 @@ Module::Interface::~Interface() = default;

 class IUser final : public ServiceFramework<IUser> {
 public:
-    IUser(Module::Interface& nfp_interface, Core::System& system)
-        : ServiceFramework("NFP::IUser"), nfp_interface(nfp_interface), system(system) {
+    IUser(Module::Interface& nfp_interface)
+        : ServiceFramework("NFP::IUser"), nfp_interface(nfp_interface) {
        static const FunctionInfo functions[] = {
            {0, &IUser::Initialize, "Initialize"},
            {1, &IUser::Finalize, "Finalize"},
@@ -65,7 +65,7 @@ public:
        };
        RegisterHandlers(functions);

-        auto& kernel = system.Kernel();
+        auto& kernel = Core::System::GetInstance().Kernel();
        deactivate_event = Kernel::WritableEvent::CreateEventPair(
            kernel, Kernel::ResetType::Automatic, "IUser:DeactivateEvent");
        availability_change_event = Kernel::WritableEvent::CreateEventPair(
@@ -324,7 +324,6 @@ private:
    Kernel::EventPair deactivate_event;
    Kernel::EventPair availability_change_event;
    const Module::Interface& nfp_interface;
-    Core::System& system;
 };

 void Module::Interface::CreateUserInterface(Kernel::HLERequestContext& ctx) {
@@ -332,7 +331,7 @@ void Module::Interface::CreateUserInterface(Kernel::HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IUser>(*this, system);
+    rb.PushIpcInterface<IUser>(*this);
 }

 bool Module::Interface::LoadAmiibo(const std::vector<u8>& buffer) {
@@ -354,9 +353,9 @@ const Module::Interface::AmiiboFile& Module::Interface::GetAmiiboBuffer() const
    return amiibo;
 }

-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
+void InstallInterfaces(SM::ServiceManager& service_manager) {
    auto module = std::make_shared<Module>();
-    std::make_shared<NFP_User>(module, system)->InstallAsService(service_manager);
+    std::make_shared<NFP_User>(module)->InstallAsService(service_manager);
 }

 } // namespace Service::NFP
@@ -16,7 +16,7 @@ class Module final {
 public:
    class Interface : public ServiceFramework<Interface> {
    public:
-        explicit Interface(std::shared_ptr<Module> module, Core::System& system, const char* name);
+        explicit Interface(std::shared_ptr<Module> module, const char* name);
        ~Interface() override;

        struct ModelInfo {
@@ -43,10 +43,9 @@ public:

    protected:
        std::shared_ptr<Module> module;
-        Core::System& system;
    };
 };

-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager);

 } // namespace Service::NFP
@@ -6,8 +6,8 @@

 namespace Service::NFP {

-NFP_User::NFP_User(std::shared_ptr<Module> module, Core::System& system)
-    : Module::Interface(std::move(module), system, "nfp:user") {
+NFP_User::NFP_User(std::shared_ptr<Module> module)
+    : Module::Interface(std::move(module), "nfp:user") {
    static const FunctionInfo functions[] = {
        {0, &NFP_User::CreateUserInterface, "CreateUserInterface"},
    };
@@ -10,7 +10,7 @@ namespace Service::NFP {

 class NFP_User final : public Module::Interface {
 public:
-    explicit NFP_User(std::shared_ptr<Module> module, Core::System& system);
+    explicit NFP_User(std::shared_ptr<Module> module);
    ~NFP_User() override;
 };

@@ -31,7 +31,7 @@ public:

 class IRequest final : public ServiceFramework<IRequest> {
 public:
-    explicit IRequest(Core::System& system) : ServiceFramework("IRequest") {
+    explicit IRequest() : ServiceFramework("IRequest") {
        static const FunctionInfo functions[] = {
            {0, &IRequest::GetRequestState, "GetRequestState"},
            {1, &IRequest::GetResult, "GetResult"},
@@ -61,7 +61,7 @@ public:
        };
        RegisterHandlers(functions);

-        auto& kernel = system.Kernel();
+        auto& kernel = Core::System::GetInstance().Kernel();
        event1 = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Automatic,
                                                        "IRequest:Event1");
        event2 = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Automatic,
@@ -130,7 +130,7 @@ public:

 class IGeneralService final : public ServiceFramework<IGeneralService> {
 public:
-    IGeneralService(Core::System& system);
+    IGeneralService();

 private:
    void GetClientId(Kernel::HLERequestContext& ctx) {
@@ -155,7 +155,7 @@ private:
        IPC::ResponseBuilder rb{ctx, 2, 0, 1};

        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IRequest>(system);
+        rb.PushIpcInterface<IRequest>();
    }
    void RemoveNetworkProfile(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_NIFM, "(STUBBED) called");
@@ -198,11 +198,9 @@ private:
        rb.Push(RESULT_SUCCESS);
        rb.Push<u8>(0);
    }
-    Core::System& system;
 };

-IGeneralService::IGeneralService(Core::System& system)
-    : ServiceFramework("IGeneralService"), system(system) {
+IGeneralService::IGeneralService() : ServiceFramework("IGeneralService") {
    static const FunctionInfo functions[] = {
        {1, &IGeneralService::GetClientId, "GetClientId"},
        {2, &IGeneralService::CreateScanRequest, "CreateScanRequest"},
@@ -247,8 +245,7 @@ IGeneralService::IGeneralService(Core::System& system)

 class NetworkInterface final : public ServiceFramework<NetworkInterface> {
 public:
-    explicit NetworkInterface(const char* name, Core::System& system)
-        : ServiceFramework{name}, system(system) {
+    explicit NetworkInterface(const char* name) : ServiceFramework{name} {
        static const FunctionInfo functions[] = {
            {4, &NetworkInterface::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
            {5, &NetworkInterface::CreateGeneralService, "CreateGeneralService"},
@@ -261,7 +258,7 @@ public:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IGeneralService>(system);
+        rb.PushIpcInterface<IGeneralService>();
    }

    void CreateGeneralService(Kernel::HLERequestContext& ctx) {
@@ -269,17 +266,14 @@ public:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IGeneralService>(system);
+        rb.PushIpcInterface<IGeneralService>();
    }
-
-private:
-    Core::System& system;
 };

-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    std::make_shared<NetworkInterface>("nifm:a", system)->InstallAsService(service_manager);
-    std::make_shared<NetworkInterface>("nifm:s", system)->InstallAsService(service_manager);
-    std::make_shared<NetworkInterface>("nifm:u", system)->InstallAsService(service_manager);
+void InstallInterfaces(SM::ServiceManager& service_manager) {
+    std::make_shared<NetworkInterface>("nifm:a")->InstallAsService(service_manager);
+    std::make_shared<NetworkInterface>("nifm:s")->InstallAsService(service_manager);
+    std::make_shared<NetworkInterface>("nifm:u")->InstallAsService(service_manager);
 }

 } // namespace Service::NIFM
@@ -8,13 +8,9 @@ namespace Service::SM {
 class ServiceManager;
 }

-namespace Core {
-class System;
-}
-
 namespace Service::NIFM {

 /// Registers all NIFM services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager);

 } // namespace Service::NIFM
@@ -126,7 +126,7 @@ public:
 class IEnsureNetworkClockAvailabilityService final
    : public ServiceFramework<IEnsureNetworkClockAvailabilityService> {
 public:
-    explicit IEnsureNetworkClockAvailabilityService(Core::System& system)
+    IEnsureNetworkClockAvailabilityService()
        : ServiceFramework("IEnsureNetworkClockAvailabilityService") {
        static const FunctionInfo functions[] = {
            {0, &IEnsureNetworkClockAvailabilityService::StartTask, "StartTask"},
@@ -139,7 +139,7 @@ public:
        };
        RegisterHandlers(functions);

-        auto& kernel = system.Kernel();
+        auto& kernel = Core::System::GetInstance().Kernel();
        finished_event = Kernel::WritableEvent::CreateEventPair(
            kernel, Kernel::ResetType::Automatic,
            "IEnsureNetworkClockAvailabilityService:FinishEvent");
@@ -200,7 +200,7 @@ private:

 class NTC final : public ServiceFramework<NTC> {
 public:
-    explicit NTC(Core::System& system) : ServiceFramework{"ntc"}, system(system) {
+    explicit NTC() : ServiceFramework{"ntc"} {
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, &NTC::OpenEnsureNetworkClockAvailabilityService, "OpenEnsureNetworkClockAvailabilityService"},
@@ -218,7 +218,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IEnsureNetworkClockAvailabilityService>(system);
+        rb.PushIpcInterface<IEnsureNetworkClockAvailabilityService>();
    }

    // TODO(ogniK): Do we need these?
@@ -235,14 +235,13 @@ private:
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }
-    Core::System& system;
 };

-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
+void InstallInterfaces(SM::ServiceManager& sm) {
    std::make_shared<NIM>()->InstallAsService(sm);
    std::make_shared<NIM_ECA>()->InstallAsService(sm);
    std::make_shared<NIM_SHP>()->InstallAsService(sm);
-    std::make_shared<NTC>(system)->InstallAsService(sm);
+    std::make_shared<NTC>()->InstallAsService(sm);
 }

 } // namespace Service::NIM
@@ -8,12 +8,8 @@ namespace Service::SM {
 class ServiceManager;
 }

-namespace Core {
-class System;
-}
-
 namespace Service::NIM {

-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void InstallInterfaces(SM::ServiceManager& sm);

 } // namespace Service::NIM
@@ -617,8 +617,7 @@ public:
    }
 };

-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-
+void InstallInterfaces(SM::ServiceManager& service_manager, FileSystem::FileSystemController& fsc) {
    std::make_shared<NS>("ns:am2")->InstallAsService(service_manager);
    std::make_shared<NS>("ns:ec")->InstallAsService(service_manager);
    std::make_shared<NS>("ns:rid")->InstallAsService(service_manager);
@@ -629,7 +628,7 @@ void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system
    std::make_shared<NS_SU>()->InstallAsService(service_manager);
    std::make_shared<NS_VM>()->InstallAsService(service_manager);

-    std::make_shared<PL_U>(system)->InstallAsService(service_manager);
+    std::make_shared<PL_U>(fsc)->InstallAsService(service_manager);
 }

 } // namespace Service::NS
@@ -97,7 +97,8 @@ private:
 };

 /// Registers all NS services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager, FileSystem::FileSystemController& fsc);

 } // namespace NS
+
 } // namespace Service
@@ -150,9 +150,8 @@ struct PL_U::Impl {
    std::vector<FontRegion> shared_font_regions;
 };

-PL_U::PL_U(Core::System& system)
-    : ServiceFramework("pl:u"), impl{std::make_unique<Impl>()}, system(system) {
-
+PL_U::PL_U(FileSystem::FileSystemController& fsc)
+    : ServiceFramework("pl:u"), impl{std::make_unique<Impl>()} {
    static const FunctionInfo functions[] = {
        {0, &PL_U::RequestLoad, "RequestLoad"},
        {1, &PL_U::GetLoadState, "GetLoadState"},
@@ -162,9 +161,6 @@ PL_U::PL_U(Core::System& system)
        {5, &PL_U::GetSharedFontInOrderOfPriority, "GetSharedFontInOrderOfPriority"},
    };
    RegisterHandlers(functions);
-
-    auto& fsc = system.GetFileSystemController();
-
    // Attempt to load shared font data from disk
    const auto* nand = fsc.GetSystemNANDContents();
    std::size_t offset = 0;
@@ -329,7 +325,7 @@ void PL_U::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx) {
                                                       Kernel::MemoryState::Shared);

    // Create shared font memory object
-    auto& kernel = system.Kernel();
+    auto& kernel = Core::System::GetInstance().Kernel();
    impl->shared_font_mem = Kernel::SharedMemory::Create(
        kernel, Core::CurrentProcess(), SHARED_FONT_MEM_SIZE, Kernel::MemoryPermission::ReadWrite,
        Kernel::MemoryPermission::Read, SHARED_FONT_MEM_VADDR, Kernel::MemoryRegion::BASE,
@@ -17,7 +17,7 @@ namespace NS {

 class PL_U final : public ServiceFramework<PL_U> {
 public:
-    explicit PL_U(Core::System& system);
+    PL_U(FileSystem::FileSystemController& fsc);
    ~PL_U() override;

 private:
@@ -30,7 +30,6 @@ private:

    struct Impl;
    std::unique_ptr<Impl> impl;
-    Core::System& system;
 };

 } // namespace NS
@@ -9,7 +9,6 @@
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "core/hle/service/nvdrv/nvdata.h"
-#include "core/hle/service/service.h"

 namespace Core {
 class System;
@@ -39,9 +38,8 @@ public:
     * @param output A buffer where the output data will be written to.
     * @returns The result code of the ioctl.
     */
-    virtual u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-                      std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-                      IoctlVersion version) = 0;
+    virtual u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+                      IoctlCtrl& ctrl) = 0;

 protected:
    Core::System& system;
@@ -17,9 +17,8 @@ nvdisp_disp0::nvdisp_disp0(Core::System& system, std::shared_ptr<nvmap> nvmap_de
    : nvdevice(system), nvmap_dev(std::move(nvmap_dev)) {}
 nvdisp_disp0 ::~nvdisp_disp0() = default;

-u32 nvdisp_disp0::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-                        std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-                        IoctlVersion version) {
+u32 nvdisp_disp0::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+                        IoctlCtrl& ctrl) {
    UNIMPLEMENTED_MSG("Unimplemented ioctl");
    return 0;
 }
@@ -20,9 +20,8 @@ public:
    explicit nvdisp_disp0(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
    ~nvdisp_disp0() override;

-    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-              IoctlVersion version) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+              IoctlCtrl& ctrl) override;

    /// Performs a screen flip, drawing the buffer pointed to by the handle.
    void flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u32 height, u32 stride,
@@ -26,9 +26,8 @@ nvhost_as_gpu::nvhost_as_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_
    : nvdevice(system), nvmap_dev(std::move(nvmap_dev)) {}
 nvhost_as_gpu::~nvhost_as_gpu() = default;

-u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-                         std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-                         IoctlVersion version) {
+u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+                         IoctlCtrl& ctrl) {
    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
              command.raw, input.size(), output.size());

@@ -20,9 +20,8 @@ public:
    explicit nvhost_as_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
    ~nvhost_as_gpu() override;

-    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-              IoctlVersion version) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+              IoctlCtrl& ctrl) override;

 private:
    enum class IoctlCommand : u32_le {
@@ -19,9 +19,8 @@ nvhost_ctrl::nvhost_ctrl(Core::System& system, EventInterface& events_interface)
    : nvdevice(system), events_interface{events_interface} {}
 nvhost_ctrl::~nvhost_ctrl() = default;

-u32 nvhost_ctrl::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-                       std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-                       IoctlVersion version) {
+u32 nvhost_ctrl::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+                       IoctlCtrl& ctrl) {
    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
              command.raw, input.size(), output.size());

@@ -17,9 +17,8 @@ public:
    explicit nvhost_ctrl(Core::System& system, EventInterface& events_interface);
    ~nvhost_ctrl() override;

-    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-              IoctlVersion version) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+              IoctlCtrl& ctrl) override;

 private:
    enum class IoctlCommand : u32_le {
@@ -15,15 +15,14 @@ namespace Service::Nvidia::Devices {
 nvhost_ctrl_gpu::nvhost_ctrl_gpu(Core::System& system) : nvdevice(system) {}
 nvhost_ctrl_gpu::~nvhost_ctrl_gpu() = default;

-u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input,
-                           const std::vector<u8>& input2, std::vector<u8>& output,
-                           std::vector<u8>& output2, IoctlCtrl& ctrl, IoctlVersion version) {
+u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+                           IoctlCtrl& ctrl) {
    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
              command.raw, input.size(), output.size());

    switch (static_cast<IoctlCommand>(command.raw)) {
    case IoctlCommand::IocGetCharacteristicsCommand:
-        return GetCharacteristics(input, output, output2, version);
+        return GetCharacteristics(input, output);
    case IoctlCommand::IocGetTPCMasksCommand:
        return GetTPCMasks(input, output);
    case IoctlCommand::IocGetActiveSlotMaskCommand:
@@ -45,8 +44,7 @@ u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input,
    return 0;
 }

-u32 nvhost_ctrl_gpu::GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output,
-                                        std::vector<u8>& output2, IoctlVersion version) {
+u32 nvhost_ctrl_gpu::GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output) {
    LOG_DEBUG(Service_NVDRV, "called");
    IoctlCharacteristics params{};
    std::memcpy(&params, input.data(), input.size());
@@ -87,13 +85,7 @@ u32 nvhost_ctrl_gpu::GetCharacteristics(const std::vector<u8>& input, std::vecto
    params.gc.gr_compbit_store_base_hw = 0x0;
    params.gpu_characteristics_buf_size = 0xA0;
    params.gpu_characteristics_buf_addr = 0xdeadbeef; // Cannot be 0 (UNUSED)
-
-    if (version == IoctlVersion::Version3) {
-        std::memcpy(output.data(), input.data(), output.size());
-        std::memcpy(output2.data(), &params.gc, output2.size());
-    } else {
-        std::memcpy(output.data(), &params, output.size());
-    }
+    std::memcpy(output.data(), &params, output.size());
    return 0;
 }

@@ -16,9 +16,8 @@ public:
    explicit nvhost_ctrl_gpu(Core::System& system);
    ~nvhost_ctrl_gpu() override;

-    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-              IoctlVersion version) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+              IoctlCtrl& ctrl) override;

 private:
    enum class IoctlCommand : u32_le {
@@ -163,8 +162,7 @@ private:
    };
    static_assert(sizeof(IoctlGetGpuTime) == 8, "IoctlGetGpuTime is incorrect size");

-    u32 GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output,
-                           std::vector<u8>& output2, IoctlVersion version);
+    u32 GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output);
    u32 GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output);
    u32 GetActiveSlotMask(const std::vector<u8>& input, std::vector<u8>& output);
    u32 ZCullGetCtxSize(const std::vector<u8>& input, std::vector<u8>& output);
@@ -17,9 +17,8 @@ nvhost_gpu::nvhost_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
    : nvdevice(system), nvmap_dev(std::move(nvmap_dev)) {}
 nvhost_gpu::~nvhost_gpu() = default;

-u32 nvhost_gpu::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-                      std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-                      IoctlVersion version) {
+u32 nvhost_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+                      IoctlCtrl& ctrl) {
    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
              command.raw, input.size(), output.size());

@@ -51,7 +50,7 @@ u32 nvhost_gpu::ioctl(Ioctl command, const std::vector<u8>& input, const std::ve
            return SubmitGPFIFO(input, output);
        }
        if (command.cmd == NVGPU_IOCTL_CHANNEL_KICKOFF_PB) {
-            return KickoffPB(input, output, input2, version);
+            return KickoffPB(input, output);
        }
    }

@@ -174,8 +173,7 @@ u32 nvhost_gpu::SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& outp
    return 0;
 }

-u32 nvhost_gpu::KickoffPB(const std::vector<u8>& input, std::vector<u8>& output,
-                          const std::vector<u8>& input2, IoctlVersion version) {
+u32 nvhost_gpu::KickoffPB(const std::vector<u8>& input, std::vector<u8>& output) {
    if (input.size() < sizeof(IoctlSubmitGpfifo)) {
        UNIMPLEMENTED();
    }
@@ -185,13 +183,9 @@ u32 nvhost_gpu::KickoffPB(const std::vector<u8>& input, std::vector<u8>& output,
              params.num_entries, params.flags.raw);

    Tegra::CommandList entries(params.num_entries);
-    if (version == IoctlVersion::Version2) {
-        std::memcpy(entries.data(), input2.data(),
-                    params.num_entries * sizeof(Tegra::CommandListHeader));
-    } else {
-        Memory::ReadBlock(params.address, entries.data(),
-                          params.num_entries * sizeof(Tegra::CommandListHeader));
-    }
+    Memory::ReadBlock(params.address, entries.data(),
+                      params.num_entries * sizeof(Tegra::CommandListHeader));
+
    UNIMPLEMENTED_IF(params.flags.add_wait.Value() != 0);
    UNIMPLEMENTED_IF(params.flags.add_increment.Value() != 0);

@@ -24,9 +24,8 @@ public:
    explicit nvhost_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
    ~nvhost_gpu() override;

-    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-              IoctlVersion version) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+              IoctlCtrl& ctrl) override;

 private:
    enum class IoctlCommand : u32_le {
@@ -184,8 +183,7 @@ private:
    u32 AllocGPFIFOEx2(const std::vector<u8>& input, std::vector<u8>& output);
    u32 AllocateObjectContext(const std::vector<u8>& input, std::vector<u8>& output);
    u32 SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 KickoffPB(const std::vector<u8>& input, std::vector<u8>& output,
-                  const std::vector<u8>& input2, IoctlVersion version);
+    u32 KickoffPB(const std::vector<u8>& input, std::vector<u8>& output);
    u32 GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output);
    u32 ChannelSetTimeout(const std::vector<u8>& input, std::vector<u8>& output);

@@ -13,9 +13,8 @@ namespace Service::Nvidia::Devices {
 nvhost_nvdec::nvhost_nvdec(Core::System& system) : nvdevice(system) {}
 nvhost_nvdec::~nvhost_nvdec() = default;

-u32 nvhost_nvdec::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-                        std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-                        IoctlVersion version) {
+u32 nvhost_nvdec::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+                        IoctlCtrl& ctrl) {
    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
              command.raw, input.size(), output.size());

@@ -16,9 +16,8 @@ public:
    explicit nvhost_nvdec(Core::System& system);
    ~nvhost_nvdec() override;

-    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-              IoctlVersion version) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+              IoctlCtrl& ctrl) override;

 private:
    enum class IoctlCommand : u32_le {
@@ -13,9 +13,8 @@ namespace Service::Nvidia::Devices {
 nvhost_nvjpg::nvhost_nvjpg(Core::System& system) : nvdevice(system) {}
 nvhost_nvjpg::~nvhost_nvjpg() = default;

-u32 nvhost_nvjpg::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-                        std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-                        IoctlVersion version) {
+u32 nvhost_nvjpg::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+                        IoctlCtrl& ctrl) {
    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
              command.raw, input.size(), output.size());

@@ -16,9 +16,8 @@ public:
    explicit nvhost_nvjpg(Core::System& system);
    ~nvhost_nvjpg() override;

-    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-              IoctlVersion version) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+              IoctlCtrl& ctrl) override;

 private:
    enum class IoctlCommand : u32_le {
@@ -13,9 +13,8 @@ namespace Service::Nvidia::Devices {
 nvhost_vic::nvhost_vic(Core::System& system) : nvdevice(system) {}
 nvhost_vic::~nvhost_vic() = default;

-u32 nvhost_vic::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-                      std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-                      IoctlVersion version) {
+u32 nvhost_vic::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+                      IoctlCtrl& ctrl) {
    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
              command.raw, input.size(), output.size());

@@ -16,9 +16,8 @@ public:
    explicit nvhost_vic(Core::System& system);
    ~nvhost_vic() override;

-    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-              IoctlVersion version) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+              IoctlCtrl& ctrl) override;

 private:
    enum class IoctlCommand : u32_le {
@@ -28,9 +28,8 @@ VAddr nvmap::GetObjectAddress(u32 handle) const {
    return object->addr;
 }

-u32 nvmap::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-                 std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-                 IoctlVersion version) {
+u32 nvmap::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+                 IoctlCtrl& ctrl) {
    switch (static_cast<IoctlCommand>(command.raw)) {
    case IoctlCommand::Create:
        return IocCreate(input, output);
@@ -22,9 +22,8 @@ public:
    /// Returns the allocated address of an nvmap object given its handle.
    VAddr GetObjectAddress(u32 handle) const;

-    u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-              IoctlVersion version) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+              IoctlCtrl& ctrl) override;

    /// Represents an nvmap object.
    struct Object {
@@ -33,77 +33,42 @@ void NVDRV::Open(Kernel::HLERequestContext& ctx) {
    rb.Push<u32>(0);
 }

-void NVDRV::IoctlBase(Kernel::HLERequestContext& ctx, IoctlVersion version) {
+void NVDRV::Ioctl(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_NVDRV, "called");
+
    IPC::RequestParser rp{ctx};
    u32 fd = rp.Pop<u32>();
    u32 command = rp.Pop<u32>();

-    /// Ioctl 3 has 2 outputs, first in the input params, second is the result
-    std::vector<u8> output(ctx.GetWriteBufferSize(0));
-    std::vector<u8> output2;
-    if (version == IoctlVersion::Version3) {
-        output2.resize((ctx.GetWriteBufferSize(1)));
-    }
-
-    /// Ioctl2 has 2 inputs. It's used to pass data directly instead of providing a pointer.
-    /// KickOfPB uses this
-    auto input = ctx.ReadBuffer(0);
-
-    std::vector<u8> input2;
-    if (version == IoctlVersion::Version2) {
-        input2 = ctx.ReadBuffer(1);
-    }
+    std::vector<u8> output(ctx.GetWriteBufferSize());

    IoctlCtrl ctrl{};

-    u32 result = nvdrv->Ioctl(fd, command, input, input2, output, output2, ctrl, version);
+    u32 result = nvdrv->Ioctl(fd, command, ctx.ReadBuffer(), output, ctrl);

    if (ctrl.must_delay) {
        ctrl.fresh_call = false;
-        ctx.SleepClientThread("NVServices::DelayedResponse", ctrl.timeout,
-                              [=](Kernel::SharedPtr<Kernel::Thread> thread,
-                                  Kernel::HLERequestContext& ctx,
-                                  Kernel::ThreadWakeupReason reason) {
-                                  IoctlCtrl ctrl2{ctrl};
-                                  std::vector<u8> tmp_output = output;
-                                  std::vector<u8> tmp_output2 = output2;
-                                  u32 result = nvdrv->Ioctl(fd, command, input, input2, tmp_output,
-                                                            tmp_output2, ctrl2, version);
-                                  ctx.WriteBuffer(tmp_output, 0);
-                                  if (version == IoctlVersion::Version3) {
-                                      ctx.WriteBuffer(tmp_output2, 1);
-                                  }
-                                  IPC::ResponseBuilder rb{ctx, 3};
-                                  rb.Push(RESULT_SUCCESS);
-                                  rb.Push(result);
-                              },
-                              nvdrv->GetEventWriteable(ctrl.event_id));
+        ctx.SleepClientThread(
+            "NVServices::DelayedResponse", ctrl.timeout,
+            [=](Kernel::SharedPtr<Kernel::Thread> thread, Kernel::HLERequestContext& ctx,
+                Kernel::ThreadWakeupReason reason) {
+                IoctlCtrl ctrl2{ctrl};
+                std::vector<u8> output2 = output;
+                u32 result = nvdrv->Ioctl(fd, command, ctx.ReadBuffer(), output2, ctrl2);
+                ctx.WriteBuffer(output2);
+                IPC::ResponseBuilder rb{ctx, 3};
+                rb.Push(RESULT_SUCCESS);
+                rb.Push(result);
+            },
+            nvdrv->GetEventWriteable(ctrl.event_id));
    } else {
        ctx.WriteBuffer(output);
-        if (version == IoctlVersion::Version3) {
-            ctx.WriteBuffer(output2, 1);
-        }
    }
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
    rb.Push(result);
 }

-void NVDRV::Ioctl(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_NVDRV, "called");
-    IoctlBase(ctx, IoctlVersion::Version1);
-}
-
-void NVDRV::Ioctl2(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_NVDRV, "called");
-    IoctlBase(ctx, IoctlVersion::Version2);
-}
-
-void NVDRV::Ioctl3(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_NVDRV, "called");
-    IoctlBase(ctx, IoctlVersion::Version3);
-}
-
 void NVDRV::Close(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_NVDRV, "called");

@@ -189,8 +154,8 @@ NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
        {8, &NVDRV::SetClientPID, "SetClientPID"},
        {9, &NVDRV::DumpGraphicsMemoryInfo, "DumpGraphicsMemoryInfo"},
        {10, nullptr, "InitializeDevtools"},
-        {11, &NVDRV::Ioctl2, "Ioctl2"},
-        {12, &NVDRV::Ioctl3, "Ioctl3"},
+        {11, &NVDRV::Ioctl, "Ioctl2"},
+        {12, nullptr, "Ioctl3"},
        {13, &NVDRV::FinishInitialize, "FinishInitialize"},
    };
    RegisterHandlers(functions);
@@ -24,8 +24,6 @@ public:
 private:
    void Open(Kernel::HLERequestContext& ctx);
    void Ioctl(Kernel::HLERequestContext& ctx);
-    void Ioctl2(Kernel::HLERequestContext& ctx);
-    void Ioctl3(Kernel::HLERequestContext& ctx);
    void Close(Kernel::HLERequestContext& ctx);
    void Initialize(Kernel::HLERequestContext& ctx);
    void QueryEvent(Kernel::HLERequestContext& ctx);
@@ -33,7 +31,6 @@ private:
    void FinishInitialize(Kernel::HLERequestContext& ctx);
    void GetStatus(Kernel::HLERequestContext& ctx);
    void DumpGraphicsMemoryInfo(Kernel::HLERequestContext& ctx);
-    void IoctlBase(Kernel::HLERequestContext& ctx, IoctlVersion version);

    std::shared_ptr<Module> nvdrv;

@@ -34,12 +34,6 @@ enum class EventState {
    Busy = 3,
 };

-enum class IoctlVersion : u32 {
-    Version1,
-    Version2,
-    Version3,
-};
-
 struct IoctlCtrl {
    // First call done to the servioce for services that call itself again after a call.
    bool fresh_call{true};
@@ -71,14 +71,13 @@ u32 Module::Open(const std::string& device_name) {
    return fd;
 }

-u32 Module::Ioctl(u32 fd, u32 command, const std::vector<u8>& input, const std::vector<u8>& input2,
-                  std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-                  IoctlVersion version) {
+u32 Module::Ioctl(u32 fd, u32 command, const std::vector<u8>& input, std::vector<u8>& output,
+                  IoctlCtrl& ctrl) {
    auto itr = open_files.find(fd);
    ASSERT_MSG(itr != open_files.end(), "Tried to talk to an invalid device");

    auto& device = itr->second;
-    return device->ioctl({command}, input, input2, output, output2, ctrl, version);
+    return device->ioctl({command}, input, output, ctrl);
 }

 ResultCode Module::Close(u32 fd) {
@@ -106,9 +106,8 @@ public:
    /// Opens a device node and returns a file descriptor to it.
    u32 Open(const std::string& device_name);
    /// Sends an ioctl command to the specified file descriptor.
-    u32 Ioctl(u32 fd, u32 command, const std::vector<u8>& input, const std::vector<u8>& input2,
-              std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-              IoctlVersion version);
+    u32 Ioctl(u32 fd, u32 command, const std::vector<u8>& input, std::vector<u8>& output,
+              IoctlCtrl& ctrl);
    /// Closes a device file descriptor and returns operation success.
    ResultCode Close(u32 fd);

@@ -29,28 +29,26 @@ namespace Service::NVFlinger {
 constexpr s64 frame_ticks = static_cast<s64>(Core::Timing::BASE_CLOCK_RATE / 60);
 constexpr s64 frame_ticks_30fps = static_cast<s64>(Core::Timing::BASE_CLOCK_RATE / 30);

-NVFlinger::NVFlinger(Core::System& system) : system(system) {
-    displays.emplace_back(0, "Default", system);
-    displays.emplace_back(1, "External", system);
-    displays.emplace_back(2, "Edid", system);
-    displays.emplace_back(3, "Internal", system);
-    displays.emplace_back(4, "Null", system);
+NVFlinger::NVFlinger(Core::Timing::CoreTiming& core_timing) : core_timing{core_timing} {
+    displays.emplace_back(0, "Default");
+    displays.emplace_back(1, "External");
+    displays.emplace_back(2, "Edid");
+    displays.emplace_back(3, "Internal");
+    displays.emplace_back(4, "Null");

    // Schedule the screen composition events
-    composition_event = system.CoreTiming().RegisterEvent(
-        "ScreenComposition", [this](u64 userdata, s64 cycles_late) {
-            Compose();
-            const auto ticks =
-                Settings::values.force_30fps_mode ? frame_ticks_30fps : GetNextTicks();
-            this->system.CoreTiming().ScheduleEvent(std::max<s64>(0LL, ticks - cycles_late),
-                                                    composition_event);
-        });
+    composition_event = core_timing.RegisterEvent("ScreenComposition", [this](u64 userdata,
+                                                                              s64 cycles_late) {
+        Compose();
+        const auto ticks = Settings::values.force_30fps_mode ? frame_ticks_30fps : GetNextTicks();
+        this->core_timing.ScheduleEvent(std::max<s64>(0LL, ticks - cycles_late), composition_event);
+    });

-    system.CoreTiming().ScheduleEvent(frame_ticks, composition_event);
+    core_timing.ScheduleEvent(frame_ticks, composition_event);
 }

 NVFlinger::~NVFlinger() {
-    system.CoreTiming().UnscheduleEvent(composition_event, 0);
+    core_timing.UnscheduleEvent(composition_event, 0);
 }

 void NVFlinger::SetNVDrvInstance(std::shared_ptr<Nvidia::Module> instance) {
@@ -187,9 +185,11 @@ void NVFlinger::Compose() {
        MicroProfileFlip();

        if (!buffer) {
+            auto& system_instance = Core::System::GetInstance();
+
            // There was no queued buffer to draw, render previous frame
-            system.GetPerfStats().EndGameFrame();
-            system.GPU().SwapBuffers({});
+            system_instance.GetPerfStats().EndGameFrame();
+            system_instance.GPU().SwapBuffers({});
            continue;
        }

@@ -38,7 +38,7 @@ class BufferQueue;

 class NVFlinger final {
 public:
-    explicit NVFlinger(Core::System& system);
+    explicit NVFlinger(Core::Timing::CoreTiming& core_timing);
    ~NVFlinger();

    /// Sets the NVDrv module instance to use to send buffers to the GPU.
@@ -105,7 +105,8 @@ private:
    /// Event that handles screen composition.
    Core::Timing::EventType* composition_event;

-    Core::System& system;
+    /// Core timing instance for registering/unregistering the composition event.
+    Core::Timing::CoreTiming& core_timing;
 };

 } // namespace Service::NVFlinger
@@ -15,7 +15,7 @@ namespace Service::PlayReport {

 class PlayReport final : public ServiceFramework<PlayReport> {
 public:
-    explicit PlayReport(const char* name, Core::System& system)
+    explicit PlayReport(Core::System& system, const char* name)
        : ServiceFramework{name}, system(system) {
        // clang-format off
        static const FunctionInfo functions[] = {
@@ -128,12 +128,12 @@ private:
    Core::System& system;
 };

-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    std::make_shared<PlayReport>("prepo:a", system)->InstallAsService(service_manager);
-    std::make_shared<PlayReport>("prepo:a2", system)->InstallAsService(service_manager);
-    std::make_shared<PlayReport>("prepo:m", system)->InstallAsService(service_manager);
-    std::make_shared<PlayReport>("prepo:s", system)->InstallAsService(service_manager);
-    std::make_shared<PlayReport>("prepo:u", system)->InstallAsService(service_manager);
+void InstallInterfaces(Core::System& system) {
+    std::make_shared<PlayReport>(system, "prepo:a")->InstallAsService(system.ServiceManager());
+    std::make_shared<PlayReport>(system, "prepo:a2")->InstallAsService(system.ServiceManager());
+    std::make_shared<PlayReport>(system, "prepo:m")->InstallAsService(system.ServiceManager());
+    std::make_shared<PlayReport>(system, "prepo:s")->InstallAsService(system.ServiceManager());
+    std::make_shared<PlayReport>(system, "prepo:u")->InstallAsService(system.ServiceManager());
 }

 } // namespace Service::PlayReport
@@ -8,12 +8,8 @@ namespace Service::SM {
 class ServiceManager;
 }

-namespace Core {
-class System;
-}
-
 namespace Service::PlayReport {

-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void InstallInterfaces(Core::System& system);

 } // namespace Service::PlayReport
@@ -198,50 +198,50 @@ ResultCode ServiceFrameworkBase::HandleSyncRequest(Kernel::HLERequestContext& co
 void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system) {
    // NVFlinger needs to be accessed by several services like Vi and AppletOE so we instantiate it
    // here and pass it into the respective InstallInterfaces functions.
-    auto nv_flinger = std::make_shared<NVFlinger::NVFlinger>(system);
+    auto nv_flinger = std::make_shared<NVFlinger::NVFlinger>(system.CoreTiming());
    system.GetFileSystemController().CreateFactories(*system.GetFilesystem(), false);

    SM::ServiceManager::InstallInterfaces(sm);

    Account::InstallInterfaces(system);
    AM::InstallInterfaces(*sm, nv_flinger, system);
-    AOC::InstallInterfaces(*sm, system);
+    AOC::InstallInterfaces(*sm);
    APM::InstallInterfaces(system);
    Audio::InstallInterfaces(*sm, system);
    BCAT::InstallInterfaces(*sm);
    BPC::InstallInterfaces(*sm);
-    BtDrv::InstallInterfaces(*sm, system);
-    BTM::InstallInterfaces(*sm, system);
+    BtDrv::InstallInterfaces(*sm);
+    BTM::InstallInterfaces(*sm);
    Capture::InstallInterfaces(*sm);
    ERPT::InstallInterfaces(*sm);
    ES::InstallInterfaces(*sm);
    EUPLD::InstallInterfaces(*sm);
-    Fatal::InstallInterfaces(*sm, system);
+    Fatal::InstallInterfaces(*sm);
    FGM::InstallInterfaces(*sm);
    FileSystem::InstallInterfaces(system);
-    Friend::InstallInterfaces(*sm, system);
+    Friend::InstallInterfaces(*sm);
    Glue::InstallInterfaces(system);
    GRC::InstallInterfaces(*sm);
-    HID::InstallInterfaces(*sm, system);
+    HID::InstallInterfaces(*sm);
    LBL::InstallInterfaces(*sm);
    LDN::InstallInterfaces(*sm);
-    LDR::InstallInterfaces(*sm, system);
+    LDR::InstallInterfaces(*sm);
    LM::InstallInterfaces(*sm);
    Migration::InstallInterfaces(*sm);
    Mii::InstallInterfaces(*sm);
    MM::InstallInterfaces(*sm);
    NCM::InstallInterfaces(*sm);
    NFC::InstallInterfaces(*sm);
-    NFP::InstallInterfaces(*sm, system);
-    NIFM::InstallInterfaces(*sm, system);
-    NIM::InstallInterfaces(*sm, system);
+    NFP::InstallInterfaces(*sm);
+    NIFM::InstallInterfaces(*sm);
+    NIM::InstallInterfaces(*sm);
    NPNS::InstallInterfaces(*sm);
-    NS::InstallInterfaces(*sm, system);
+    NS::InstallInterfaces(*sm, system.GetFileSystemController());
    Nvidia::InstallInterfaces(*sm, *nv_flinger, system);
    PCIe::InstallInterfaces(*sm);
    PCTL::InstallInterfaces(*sm);
    PCV::InstallInterfaces(*sm);
-    PlayReport::InstallInterfaces(*sm, system);
+    PlayReport::InstallInterfaces(system);
    PM::InstallInterfaces(system);
    PSC::InstallInterfaces(*sm);
    PSM::InstallInterfaces(*sm);
@@ -7,8 +7,8 @@
 namespace Service::Time {

 Time::Time(std::shared_ptr<Module> time, std::shared_ptr<SharedMemory> shared_memory,
-           Core::System& system, const char* name)
-    : Module::Interface(std::move(time), std::move(shared_memory), system, name) {
+           const char* name)
+    : Module::Interface(std::move(time), std::move(shared_memory), name) {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0, &Time::GetStandardUserSystemClock, "GetStandardUserSystemClock"},
@@ -13,7 +13,7 @@ class SharedMemory;
 class Time final : public Module::Interface {
 public:
    explicit Time(std::shared_ptr<Module> time, std::shared_ptr<SharedMemory> shared_memory,
-                  Core::System& system, const char* name);
+                  const char* name);
    ~Time() override;
 };

@@ -126,8 +126,8 @@ private:

 class ISteadyClock final : public ServiceFramework<ISteadyClock> {
 public:
-    ISteadyClock(std::shared_ptr<SharedMemory> shared_memory, Core::System& system)
-        : ServiceFramework("ISteadyClock"), shared_memory(shared_memory), system(system) {
+    ISteadyClock(std::shared_ptr<SharedMemory> shared_memory)
+        : ServiceFramework("ISteadyClock"), shared_memory(shared_memory) {
        static const FunctionInfo functions[] = {
            {0, &ISteadyClock::GetCurrentTimePoint, "GetCurrentTimePoint"},
        };
@@ -150,13 +150,12 @@ private:
    }

    SteadyClockTimePoint GetCurrentTimePoint() const {
-        const auto& core_timing = system.CoreTiming();
+        const auto& core_timing = Core::System::GetInstance().CoreTiming();
        const auto ms = Core::Timing::CyclesToMs(core_timing.GetTicks());
        return {static_cast<u64_le>(ms.count() / 1000), {}};
    }

    std::shared_ptr<SharedMemory> shared_memory;
-    Core::System& system;
 };

 class ITimeZoneService final : public ServiceFramework<ITimeZoneService> {
@@ -291,7 +290,7 @@ void Module::Interface::GetStandardSteadyClock(Kernel::HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISteadyClock>(shared_memory, system);
+    rb.PushIpcInterface<ISteadyClock>(shared_memory);
 }

 void Module::Interface::GetTimeZoneService(Kernel::HLERequestContext& ctx) {
@@ -326,7 +325,7 @@ void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
        return;
    }

-    const auto& core_timing = system.CoreTiming();
+    const auto& core_timing = Core::System::GetInstance().CoreTiming();
    const auto ms = Core::Timing::CyclesToMs(core_timing.GetTicks());
    const SteadyClockTimePoint steady_clock_time_point{static_cast<u64_le>(ms.count() / 1000), {}};

@@ -408,10 +407,8 @@ void Module::Interface::SetStandardUserSystemClockAutomaticCorrectionEnabled(
 }

 Module::Interface::Interface(std::shared_ptr<Module> time,
-                             std::shared_ptr<SharedMemory> shared_memory, Core::System& system,
-                             const char* name)
-    : ServiceFramework(name), time(std::move(time)), shared_memory(std::move(shared_memory)),
-      system(system) {}
+                             std::shared_ptr<SharedMemory> shared_memory, const char* name)
+    : ServiceFramework(name), time(std::move(time)), shared_memory(std::move(shared_memory)) {}

 Module::Interface::~Interface() = default;

@@ -419,11 +416,9 @@ void InstallInterfaces(Core::System& system) {
    auto time = std::make_shared<Module>();
    auto shared_mem = std::make_shared<SharedMemory>(system);

-    std::make_shared<Time>(time, shared_mem, system, "time:a")
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<Time>(time, shared_mem, system, "time:s")
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<Time>(std::move(time), shared_mem, system, "time:u")
+    std::make_shared<Time>(time, shared_mem, "time:a")->InstallAsService(system.ServiceManager());
+    std::make_shared<Time>(time, shared_mem, "time:s")->InstallAsService(system.ServiceManager());
+    std::make_shared<Time>(std::move(time), shared_mem, "time:u")
        ->InstallAsService(system.ServiceManager());
 }

@@ -80,8 +80,7 @@ public:
    class Interface : public ServiceFramework<Interface> {
    public:
        explicit Interface(std::shared_ptr<Module> time,
-                           std::shared_ptr<SharedMemory> shared_memory, Core::System& system,
-                           const char* name);
+                           std::shared_ptr<SharedMemory> shared_memory, const char* name);
        ~Interface() override;

        void GetStandardUserSystemClock(Kernel::HLERequestContext& ctx);
@@ -98,7 +97,6 @@ public:
    protected:
        std::shared_ptr<Module> time;
        std::shared_ptr<SharedMemory> shared_memory;
-        Core::System& system;
    };
 };

@@ -15,8 +15,8 @@

 namespace Service::VI {

-Display::Display(u64 id, std::string name, Core::System& system) : id{id}, name{std::move(name)} {
-    auto& kernel = system.Kernel();
+Display::Display(u64 id, std::string name) : id{id}, name{std::move(name)} {
+    auto& kernel = Core::System::GetInstance().Kernel();
    vsync_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Manual,
                                                         fmt::format("Display VSync Event {}", id));
 }
@@ -26,7 +26,7 @@ public:
    /// @param id   The unique ID for this display.
    /// @param name The name for this display.
    ///
-    Display(u64 id, std::string name, Core::System& system);
+    Display(u64 id, std::string name);
    ~Display();

    Display(const Display&) = delete;