Fixed duplicated Service NVDRV in backend.cpp, my bad

.travis.yml

@@ -42,8 +42,3 @@ deploy:
   skip_cleanup: true
   on:
     tags: true
-
-notifications:
-  webhooks:
-    urls:
-      - https://api.yuzu-emu.org/code/travis/notify

.travis/macos/build.sh

@@ -2,13 +2,13 @@
 
 set -o pipefail
 
-export MACOSX_DEPLOYMENT_TARGET=10.12
+export MACOSX_DEPLOYMENT_TARGET=10.9
 export Qt5_DIR=$(brew --prefix)/opt/qt5
 export UNICORNDIR=$(pwd)/externals/unicorn
 
 mkdir build && cd build
 cmake --version
-cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release
+cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_OSX_ARCHITECTURES="x86_64;x86_64h" -DCMAKE_BUILD_TYPE=Release
 make -j4
 
 ctest -VV -C Release

CMakeLists.txt

@@ -13,7 +13,7 @@ option(ENABLE_SDL2 "Enable the SDL2 frontend" ON)
 CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON "ENABLE_SDL2;MSVC" OFF)
 
 option(ENABLE_QT "Enable the Qt frontend" ON)
-CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "ENABLE_QT;MSVC" OFF)
+CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "ENABLE_SDL2;MSVC" OFF)
 
 option(YUZU_USE_BUNDLED_UNICORN "Build/Download bundled Unicorn" ON)
 
@@ -423,7 +423,7 @@ if(ENABLE_QT AND UNIX AND NOT APPLE)
     install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.desktop"
             DESTINATION "${CMAKE_INSTALL_PREFIX}/share/applications")
     install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.svg"
-            DESTINATION "${CMAKE_INSTALL_PREFIX}/share/icons/hicolor/scalable/apps")
+            DESTINATION "${CMAKE_INSTALL_PREFIX}/share/pixmaps")
     install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.xml"
             DESTINATION "${CMAKE_INSTALL_PREFIX}/share/mime/packages")
 endif()

src/common/logging/backend.cpp

@@ -32,20 +32,14 @@ namespace Log {
     CLS(Kernel)                                                                                    \
     SUB(Kernel, SVC)                                                                               \
     CLS(Service)                                                                                   \
-    SUB(Service, ACC)                                                                              \
-    SUB(Service, Audio)                                                                            \
-    SUB(Service, AM)                                                                               \
-    SUB(Service, APM)                                                                              \
-    SUB(Service, FS)                                                                               \
-    SUB(Service, HID)                                                                              \
-    SUB(Service, LM)                                                                               \
-    SUB(Service, NIFM)                                                                             \
-    SUB(Service, NVDRV)                                                                            \
-    SUB(Service, PCTL)                                                                             \
-    SUB(Service, SET)                                                                              \
     SUB(Service, SM)                                                                               \
-    SUB(Service, Time)                                                                             \
-    SUB(Service, VI)                                                                               \
+    SUB(Service, FS)                                                                               \
+    SUB(Service, GSP)                                                                              \
+    SUB(Service, CFG)                                                                              \
+    SUB(Service, DSP)                                                                              \
+    SUB(Service, HID)                                                                              \
+    SUB(Service, NVDRV)                                                                            \
+    SUB(Service, Audio)                                                                            \
     CLS(HW)                                                                                        \
     SUB(HW, Memory)                                                                                \
     SUB(HW, LCD)                                                                                   \

src/common/logging/log.h

@@ -49,20 +49,14 @@ enum class Class : ClassType {
     Kernel_SVC,        ///< Kernel system calls
     Service,           ///< HLE implementation of system services. Each major service
                        ///  should have its own subclass.
-    Service_ACC,       ///< The ACC (Accounts) service
-    Service_AM,        ///< The AM (Applet manager) service
-    Service_APM,       ///< The APM (Performance) service
-    Service_Audio,     ///< The Audio (Audio control) service
-    Service_FS,        ///< The FS (Filesystem) service
+    Service_SM,        ///< The SRV (Service Directory) implementation
+    Service_FS,        ///< The FS (Filesystem) service implementation
+    Service_GSP,       ///< The GSP (GPU control) service
+    Service_CFG,       ///< The CFG (Configuration) service
+    Service_DSP,       ///< The DSP (DSP control) service
     Service_HID,       ///< The HID (Human interface device) service
-    Service_LM,        ///< The LM (Logger) service
-    Service_NIFM,      ///< The NIFM (Network interface) service
     Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
-    Service_PCTL,      ///< The PCTL (Parental control) service
-    Service_SET,       ///< The SET (Settings) service
-    Service_SM,        ///< The SM (Service manager) service
-    Service_Time,      ///< The time service
-    Service_VI,        ///< The VI (Video interface) service
+    Service_Audio,     ///< The Audio (Audio control) service
     HW,                ///< Low-level hardware emulation
     HW_Memory,         ///< Memory-map and address translation
     HW_LCD,            ///< LCD register emulation

src/core/CMakeLists.txt

@@ -36,6 +36,8 @@ add_library(core STATIC
     hle/kernel/client_session.h
     hle/kernel/condition_variable.cpp
     hle/kernel/condition_variable.h
+    hle/kernel/domain.cpp
+    hle/kernel/domain.h
     hle/kernel/errors.h
     hle/kernel/event.cpp
     hle/kernel/event.h
@@ -65,6 +67,7 @@ add_library(core STATIC
     hle/kernel/svc.cpp
     hle/kernel/svc.h
     hle/kernel/svc_wrap.h
+    hle/kernel/sync_object.h
     hle/kernel/thread.cpp
     hle/kernel/thread.h
     hle/kernel/timer.cpp
@@ -84,8 +87,6 @@ add_library(core STATIC
     hle/service/acc/acc_u0.h
     hle/service/am/am.cpp
     hle/service/am/am.h
-    hle/service/am/applet_ae.cpp
-    hle/service/am/applet_ae.h
     hle/service/am/applet_oe.cpp
     hle/service/am/applet_oe.h
     hle/service/aoc/aoc_u.cpp
@@ -114,14 +115,6 @@ add_library(core STATIC
     hle/service/hid/hid.h
     hle/service/lm/lm.cpp
     hle/service/lm/lm.h
-    hle/service/nifm/nifm.cpp
-    hle/service/nifm/nifm.h
-    hle/service/nifm/nifm_a.cpp
-    hle/service/nifm/nifm_a.h
-    hle/service/nifm/nifm_s.cpp
-    hle/service/nifm/nifm_s.h
-    hle/service/nifm/nifm_u.cpp
-    hle/service/nifm/nifm_u.h
     hle/service/nvdrv/devices/nvdevice.h
     hle/service/nvdrv/devices/nvdisp_disp0.cpp
     hle/service/nvdrv/devices/nvdisp_disp0.h
@@ -129,16 +122,10 @@ add_library(core STATIC
     hle/service/nvdrv/devices/nvhost_as_gpu.h
     hle/service/nvdrv/devices/nvhost_ctrl.cpp
     hle/service/nvdrv/devices/nvhost_ctrl.h
-    hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
-    hle/service/nvdrv/devices/nvhost_ctrl_gpu.h
-    hle/service/nvdrv/devices/nvhost_gpu.cpp
-    hle/service/nvdrv/devices/nvhost_gpu.h
     hle/service/nvdrv/devices/nvmap.cpp
     hle/service/nvdrv/devices/nvmap.h
     hle/service/nvdrv/interface.cpp
     hle/service/nvdrv/interface.h
-    hle/service/nvdrv/memory_manager.cpp
-    hle/service/nvdrv/memory_manager.h
     hle/service/nvdrv/nvdrv.cpp
     hle/service/nvdrv/nvdrv.h
     hle/service/nvdrv/nvmemp.cpp
@@ -161,7 +148,6 @@ add_library(core STATIC
     hle/service/sm/sm.h
     hle/service/sockets/bsd_u.cpp
     hle/service/sockets/bsd_u.h
-    hle/service/sockets/sfdnsres.cpp
     hle/service/sockets/sfdnsres.h
     hle/service/sockets/sockets.cpp
     hle/service/sockets/sockets.h
@@ -175,10 +161,6 @@ add_library(core STATIC
     hle/service/vi/vi.h
     hle/service/vi/vi_m.cpp
     hle/service/vi/vi_m.h
-    hle/service/vi/vi_s.cpp
-    hle/service/vi/vi_s.h
-    hle/service/vi/vi_u.cpp
-    hle/service/vi/vi_u.h
     hle/shared_page.cpp
     hle/shared_page.h
     hw/hw.cpp
@@ -199,8 +181,8 @@ add_library(core STATIC
     loader/nso.h
     memory.cpp
     memory.h
-    memory_hook.h
     memory_setup.h
+    mmio.h
     perf_stats.cpp
     perf_stats.h
     settings.cpp

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -8,12 +8,9 @@
 #include <dynarmic/A64/config.h>
 #include "core/arm/dynarmic/arm_dynarmic.h"
 #include "core/core_timing.h"
-#include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/svc.h"
 #include "core/memory.h"
 
-using Vector = Dynarmic::A64::Vector;
-
 class ARM_Dynarmic_Callbacks : public Dynarmic::A64::UserCallbacks {
 public:
     explicit ARM_Dynarmic_Callbacks(ARM_Dynarmic& parent) : parent(parent) {}
@@ -31,9 +28,6 @@ public:
     u64 MemoryRead64(u64 vaddr) override {
         return Memory::Read64(vaddr);
     }
-    Vector MemoryRead128(u64 vaddr) override {
-        return {Memory::Read64(vaddr), Memory::Read64(vaddr + 8)};
-    }
 
     void MemoryWrite8(u64 vaddr, u8 value) override {
         Memory::Write8(vaddr, value);
@@ -47,10 +41,6 @@ public:
     void MemoryWrite64(u64 vaddr, u64 value) override {
         Memory::Write64(vaddr, value);
     }
-    void MemoryWrite128(u64 vaddr, Vector value) override {
-        Memory::Write64(vaddr, value[0]);
-        Memory::Write64(vaddr + 8, value[1]);
-    }
 
     void InterpreterFallback(u64 pc, size_t num_instructions) override {
         ARM_Interface::ThreadContext ctx;
@@ -62,12 +52,12 @@ public:
         num_interpreted_instructions += num_instructions;
     }
 
-    void ExceptionRaised(u64 pc, Dynarmic::A64::Exception exception) override {
-        ASSERT_MSG(false, "ExceptionRaised(exception = %zu, pc = %" PRIx64 ")",
-                   static_cast<size_t>(exception), pc);
+    void ExceptionRaised(u64 pc, Dynarmic::A64::Exception /*exception*/) override {
+        ASSERT_MSG(false, "ExceptionRaised(%" PRIx64 ")", pc);
     }
 
     void CallSVC(u32 swi) override {
+        printf("svc %x\n", swi);
         Kernel::CallSVC(swi);
     }
 
@@ -88,13 +78,9 @@ public:
     u64 tpidrr0_el0 = 0;
 };
 
-std::unique_ptr<Dynarmic::A64::Jit> MakeJit(const std::unique_ptr<ARM_Dynarmic_Callbacks>& cb) {
-    Dynarmic::A64::UserConfig config{cb.get()};
-    return std::make_unique<Dynarmic::A64::Jit>(config);
-}
-
 ARM_Dynarmic::ARM_Dynarmic()
-    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), jit(MakeJit(cb)) {
+    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)),
+      jit(Dynarmic::A64::UserConfig{cb.get()}) {
     ARM_Interface::ThreadContext ctx;
     inner_unicorn.SaveContext(ctx);
     LoadContext(ctx);
@@ -108,27 +94,27 @@ void ARM_Dynarmic::MapBackingMemory(u64 address, size_t size, u8* memory,
 }
 
 void ARM_Dynarmic::SetPC(u64 pc) {
-    jit->SetPC(pc);
+    jit.SetPC(pc);
 }
 
 u64 ARM_Dynarmic::GetPC() const {
-    return jit->GetPC();
+    return jit.GetPC();
 }
 
 u64 ARM_Dynarmic::GetReg(int index) const {
-    return jit->GetRegister(index);
+    return jit.GetRegister(index);
 }
 
 void ARM_Dynarmic::SetReg(int index, u64 value) {
-    jit->SetRegister(index, value);
+    jit.SetRegister(index, value);
 }
 
 u128 ARM_Dynarmic::GetExtReg(int index) const {
-    return jit->GetVector(index);
+    return jit.GetVector(index);
 }
 
 void ARM_Dynarmic::SetExtReg(int index, u128 value) {
-    jit->SetVector(index, value);
+    jit.SetVector(index, value);
 }
 
 u32 ARM_Dynarmic::GetVFPReg(int /*index*/) const {
@@ -141,11 +127,11 @@ void ARM_Dynarmic::SetVFPReg(int /*index*/, u32 /*value*/) {
 }
 
 u32 ARM_Dynarmic::GetCPSR() const {
-    return jit->GetPstate();
+    return jit.GetPstate();
 }
 
 void ARM_Dynarmic::SetCPSR(u32 cpsr) {
-    jit->SetPstate(cpsr);
+    jit.SetPstate(cpsr);
 }
 
 u64 ARM_Dynarmic::GetTlsAddress() const {
@@ -158,41 +144,41 @@ void ARM_Dynarmic::SetTlsAddress(u64 address) {
 
 void ARM_Dynarmic::ExecuteInstructions(int num_instructions) {
     cb->ticks_remaining = num_instructions;
-    jit->Run();
+    jit.Run();
     CoreTiming::AddTicks(num_instructions - cb->num_interpreted_instructions);
     cb->num_interpreted_instructions = 0;
 }
 
 void ARM_Dynarmic::SaveContext(ARM_Interface::ThreadContext& ctx) {
-    ctx.cpu_registers = jit->GetRegisters();
-    ctx.sp = jit->GetSP();
-    ctx.pc = jit->GetPC();
-    ctx.cpsr = jit->GetPstate();
-    ctx.fpu_registers = jit->GetVectors();
-    ctx.fpscr = jit->GetFpcr();
+    ctx.cpu_registers = jit.GetRegisters();
+    ctx.sp = jit.GetSP();
+    ctx.pc = jit.GetPC();
+    ctx.cpsr = jit.GetPstate();
+    ctx.fpu_registers = jit.GetVectors();
+    ctx.fpscr = jit.GetFpcr();
     ctx.tls_address = cb->tpidrr0_el0;
 }
 
 void ARM_Dynarmic::LoadContext(const ARM_Interface::ThreadContext& ctx) {
-    jit->SetRegisters(ctx.cpu_registers);
-    jit->SetSP(ctx.sp);
-    jit->SetPC(ctx.pc);
-    jit->SetPstate(static_cast<u32>(ctx.cpsr));
-    jit->SetVectors(ctx.fpu_registers);
-    jit->SetFpcr(static_cast<u32>(ctx.fpscr));
+    jit.SetRegisters(ctx.cpu_registers);
+    jit.SetSP(ctx.sp);
+    jit.SetPC(ctx.pc);
+    jit.SetPstate(static_cast<u32>(ctx.cpsr));
+    jit.SetVectors(ctx.fpu_registers);
+    jit.SetFpcr(static_cast<u32>(ctx.fpscr));
     cb->tpidrr0_el0 = ctx.tls_address;
 }
 
 void ARM_Dynarmic::PrepareReschedule() {
-    if (jit->IsExecuting()) {
-        jit->HaltExecution();
+    if (jit.IsExecuting()) {
+        jit.HaltExecution();
     }
 }
 
 void ARM_Dynarmic::ClearInstructionCache() {
-    jit->ClearCache();
+    jit.ClearCache();
 }
 
 void ARM_Dynarmic::PageTableChanged() {
-    jit = MakeJit(cb);
+    UNIMPLEMENTED();
 }

src/core/arm/dynarmic/arm_dynarmic.h

@@ -45,6 +45,6 @@ public:
 private:
     friend class ARM_Dynarmic_Callbacks;
     std::unique_ptr<ARM_Dynarmic_Callbacks> cb;
-    std::unique_ptr<Dynarmic::A64::Jit> jit;
+    Dynarmic::A64::Jit jit;
     ARM_Unicorn inner_unicorn;
 };

src/core/hle/ipc_helpers.h

@@ -11,6 +11,7 @@
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
+#include "core/hle/kernel/domain.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/kernel/kernel.h"
@@ -30,6 +31,11 @@ public:
     RequestHelperBase(Kernel::HLERequestContext& context)
         : context(&context), cmdbuf(context.CommandBuffer()) {}
 
+    void ValidateHeader() {
+        // DEBUG_ASSERT_MSG(index == TotalSize(), "Operations do not match the header (cmd 0x%x)",
+        //                 header.raw);
+    }
+
     void Skip(unsigned size_in_words, bool set_to_null) {
         if (set_to_null)
             memset(cmdbuf + index, 0, size_in_words * sizeof(u32));
@@ -54,30 +60,14 @@ public:
     }
 };
 
-class ResponseBuilder : public RequestHelperBase {
+class RequestBuilder : public RequestHelperBase {
 public:
-    ResponseBuilder(u32* command_buffer) : RequestHelperBase(command_buffer) {}
-
-    u32 normal_params_size{};
-    u32 num_handles_to_copy{};
-    u32 num_objects_to_move{}; ///< Domain objects or move handles, context dependent
-    std::ptrdiff_t datapayload_index{};
-
-    /// Flags used for customizing the behavior of ResponseBuilder
-    enum class Flags : u32 {
-        None = 0,
-        /// Uses move handles to move objects in the response, even when in a domain. This is
-        /// required when PushMoveObjects is used.
-        AlwaysMoveHandles = 1,
-    };
-
-    ResponseBuilder(Kernel::HLERequestContext& context, u32 normal_params_size,
-                    u32 num_handles_to_copy = 0, u32 num_objects_to_move = 0,
-                    Flags flags = Flags::None)
-
-        : RequestHelperBase(context), normal_params_size(normal_params_size),
-          num_handles_to_copy(num_handles_to_copy), num_objects_to_move(num_objects_to_move) {
+    RequestBuilder(u32* command_buffer) : RequestHelperBase(command_buffer) {}
 
+    RequestBuilder(Kernel::HLERequestContext& context, unsigned normal_params_size,
+                   u32 num_handles_to_copy = 0, u32 num_handles_to_move = 0,
+                   u32 num_domain_objects = 0)
+        : RequestHelperBase(context) {
         memset(cmdbuf, 0, sizeof(u32) * IPC::COMMAND_BUFFER_LENGTH);
 
         context.ClearIncomingObjects();
@@ -87,19 +77,12 @@ public:
         // The entire size of the raw data section in u32 units, including the 16 bytes of mandatory
         // padding.
         u32 raw_data_size = sizeof(IPC::DataPayloadHeader) / 4 + 4 + normal_params_size;
-
-        u32 num_handles_to_move{};
-        u32 num_domain_objects{};
-        const bool always_move_handles{
-            (static_cast<u32>(flags) & static_cast<u32>(Flags::AlwaysMoveHandles)) != 0};
-        if (!context.Session()->IsDomain() || always_move_handles) {
-            num_handles_to_move = num_objects_to_move;
-        } else {
-            num_domain_objects = num_objects_to_move;
-        }
-
-        if (context.Session()->IsDomain()) {
+        if (context.IsDomain()) {
             raw_data_size += sizeof(DomainMessageHeader) / 4 + num_domain_objects;
+        } else {
+            // If we're not in a domain, turn the domain object parameters into move handles.
+            num_handles_to_move += num_domain_objects;
+            num_domain_objects = 0;
         }
 
         header.data_size.Assign(raw_data_size);
@@ -118,7 +101,7 @@ public:
 
         AlignWithPadding();
 
-        if (context.Session()->IsDomain()) {
+        if (context.IsDomain()) {
             IPC::DomainMessageHeader domain_header{};
             domain_header.num_objects = num_domain_objects;
             PushRaw(domain_header);
@@ -127,13 +110,12 @@ public:
         IPC::DataPayloadHeader data_payload_header{};
         data_payload_header.magic = Common::MakeMagic('S', 'F', 'C', 'O');
         PushRaw(data_payload_header);
-
-        datapayload_index = index;
     }
 
-    template <class T>
-    void PushIpcInterface(std::shared_ptr<T> iface) {
-        if (context->Session()->IsDomain()) {
+    template <class T, class... Args>
+    void PushIpcInterface(Args&&... args) {
+        auto iface = std::make_shared<T>(std::forward<Args>(args)...);
+        if (context->IsDomain()) {
             context->AddDomainObject(std::move(iface));
         } else {
             auto sessions = Kernel::ServerSession::CreateSessionPair(iface->GetServiceName());
@@ -144,26 +126,8 @@ public:
         }
     }
 
-    template <class T, class... Args>
-    void PushIpcInterface(Args&&... args) {
-        PushIpcInterface<T>(std::make_shared<T>(std::forward<Args>(args)...));
-    }
-
-    void ValidateHeader() {
-        const size_t num_domain_objects = context->NumDomainObjects();
-        const size_t num_move_objects = context->NumMoveObjects();
-        ASSERT_MSG(!num_domain_objects || !num_move_objects,
-                   "cannot move normal handles and domain objects");
-        ASSERT_MSG((index - datapayload_index) == normal_params_size,
-                   "normal_params_size value is incorrect");
-        ASSERT_MSG((num_domain_objects + num_move_objects) == num_objects_to_move,
-                   "num_objects_to_move value is incorrect");
-        ASSERT_MSG(context->NumCopyObjects() == num_handles_to_copy,
-                   "num_handles_to_copy value is incorrect");
-    }
-
     // Validate on destruction, as there shouldn't be any case where we don't want it
-    ~ResponseBuilder() {
+    ~RequestBuilder() {
         ValidateHeader();
     }
 
@@ -191,52 +155,52 @@ public:
 /// Push ///
 
 template <>
-inline void ResponseBuilder::Push(u32 value) {
+inline void RequestBuilder::Push(u32 value) {
     cmdbuf[index++] = value;
 }
 
 template <typename T>
-void ResponseBuilder::PushRaw(const T& value) {
+void RequestBuilder::PushRaw(const T& value) {
     std::memcpy(cmdbuf + index, &value, sizeof(T));
     index += (sizeof(T) + 3) / 4; // round up to word length
 }
 
 template <>
-inline void ResponseBuilder::Push(ResultCode value) {
+inline void RequestBuilder::Push(ResultCode value) {
     // Result codes are actually 64-bit in the IPC buffer, but only the high part is discarded.
     Push(value.raw);
     Push<u32>(0);
 }
 
 template <>
-inline void ResponseBuilder::Push(u8 value) {
+inline void RequestBuilder::Push(u8 value) {
     PushRaw(value);
 }
 
 template <>
-inline void ResponseBuilder::Push(u16 value) {
+inline void RequestBuilder::Push(u16 value) {
     PushRaw(value);
 }
 
 template <>
-inline void ResponseBuilder::Push(u64 value) {
+inline void RequestBuilder::Push(u64 value) {
     Push(static_cast<u32>(value));
     Push(static_cast<u32>(value >> 32));
 }
 
 template <>
-inline void ResponseBuilder::Push(bool value) {
+inline void RequestBuilder::Push(bool value) {
     Push(static_cast<u8>(value));
 }
 
 template <typename First, typename... Other>
-void ResponseBuilder::Push(const First& first_value, const Other&... other_values) {
+void RequestBuilder::Push(const First& first_value, const Other&... other_values) {
     Push(first_value);
     Push(other_values...);
 }
 
 template <typename... O>
-inline void ResponseBuilder::PushCopyObjects(Kernel::SharedPtr<O>... pointers) {
+inline void RequestBuilder::PushCopyObjects(Kernel::SharedPtr<O>... pointers) {
     auto objects = {pointers...};
     for (auto& object : objects) {
         context->AddCopyObject(std::move(object));
@@ -244,7 +208,7 @@ inline void ResponseBuilder::PushCopyObjects(Kernel::SharedPtr<O>... pointers) {
 }
 
 template <typename... O>
-inline void ResponseBuilder::PushMoveObjects(Kernel::SharedPtr<O>... pointers) {
+inline void RequestBuilder::PushMoveObjects(Kernel::SharedPtr<O>... pointers) {
     auto objects = {pointers...};
     for (auto& object : objects) {
         context->AddMoveObject(std::move(object));
@@ -263,10 +227,15 @@ public:
         Skip(CommandIdSize, false);
     }
 
-    ResponseBuilder MakeBuilder(u32 normal_params_size, u32 num_handles_to_copy,
-                                u32 num_handles_to_move,
-                                ResponseBuilder::Flags flags = ResponseBuilder::Flags::None) {
-        return {*context, normal_params_size, num_handles_to_copy, num_handles_to_move, flags};
+    RequestBuilder MakeBuilder(u32 normal_params_size, u32 num_handles_to_copy,
+                               u32 num_handles_to_move, u32 num_domain_objects,
+                               bool validate_header = true) {
+        if (validate_header) {
+            ValidateHeader();
+        }
+
+        return {*context, normal_params_size, num_handles_to_copy, num_handles_to_move,
+                num_domain_objects};
     }
 
     template <typename T>

src/core/hle/kernel/client_session.h

@@ -7,7 +7,7 @@
 #include <memory>
 #include <string>
 #include "common/common_types.h"
-#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/sync_object.h"
 #include "core/hle/result.h"
 
 namespace Kernel {
@@ -16,7 +16,7 @@ class ServerSession;
 class Session;
 class Thread;
 
-class ClientSession final : public Object {
+class ClientSession final : public SyncObject {
 public:
     friend class ServerSession;
 
@@ -33,7 +33,7 @@ public:
         return HANDLE_TYPE;
     }
 
-    ResultCode SendSyncRequest(SharedPtr<Thread> thread);
+    ResultCode SendSyncRequest(SharedPtr<Thread> thread) override;
 
     std::string name; ///< Name of client port (optional)
 

src/core/hle/kernel/condition_variable.cpp

@@ -15,12 +15,13 @@ ConditionVariable::ConditionVariable() {}
 ConditionVariable::~ConditionVariable() {}
 
 ResultVal<SharedPtr<ConditionVariable>> ConditionVariable::Create(VAddr guest_addr,
+                                                                  VAddr mutex_addr,
                                                                   std::string name) {
     SharedPtr<ConditionVariable> condition_variable(new ConditionVariable);
 
     condition_variable->name = std::move(name);
     condition_variable->guest_addr = guest_addr;
-    condition_variable->mutex_addr = 0;
+    condition_variable->mutex_addr = mutex_addr;
 
     // Condition variables are referenced by guest address, so track this in the kernel
     g_object_address_table.Insert(guest_addr, condition_variable);

src/core/hle/kernel/condition_variable.h

@@ -19,10 +19,12 @@ public:
      * Creates a condition variable.
      * @param guest_addr Address of the object tracking the condition variable in guest memory. If
      * specified, this condition variable will update the guest object when its state changes.
+     * @param mutex_addr Optional address of a guest mutex associated with this condition variable,
+     * used by the OS for implementing events.
      * @param name Optional name of condition variable.
      * @return The created condition variable.
      */
-    static ResultVal<SharedPtr<ConditionVariable>> Create(VAddr guest_addr,
+    static ResultVal<SharedPtr<ConditionVariable>> Create(VAddr guest_addr, VAddr mutex_addr = 0,
                                                           std::string name = "Unknown");
 
     std::string GetTypeName() const override {

src/core/hle/kernel/domain.cpp

@@ -0,0 +1,63 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/client_port.h"
+#include "core/hle/kernel/domain.h"
+#include "core/hle/kernel/handle_table.h"
+#include "core/hle/kernel/hle_ipc.h"
+#include "core/hle/kernel/process.h"
+#include "core/hle/kernel/session.h"
+#include "core/hle/kernel/thread.h"
+
+namespace Kernel {
+
+ResultVal<SharedPtr<Domain>> Domain::Create(std::string name) {
+    SharedPtr<Domain> domain(new Domain);
+    domain->name = std::move(name);
+    return MakeResult(std::move(domain));
+}
+
+ResultVal<SharedPtr<Domain>> Domain::CreateFromSession(const Session& session) {
+    auto res = Create(session.port->GetName() + "_Domain");
+    auto& domain = res.Unwrap();
+    domain->request_handlers.push_back(std::move(session.server->hle_handler));
+    Kernel::g_handle_table.ConvertSessionToDomain(session, domain);
+    return res;
+}
+
+ResultCode Domain::SendSyncRequest(SharedPtr<Thread> thread) {
+    Kernel::HLERequestContext context(this);
+    u32* cmd_buf = (u32*)Memory::GetPointer(Kernel::GetCurrentThread()->GetTLSAddress());
+    context.PopulateFromIncomingCommandBuffer(cmd_buf, *Kernel::g_current_process,
+                                              Kernel::g_handle_table);
+
+    auto& domain_message_header = context.GetDomainMessageHeader();
+    if (domain_message_header) {
+        // If there is a DomainMessageHeader, then this is CommandType "Request"
+        const u32 object_id{context.GetDomainMessageHeader()->object_id};
+        switch (domain_message_header->command) {
+        case IPC::DomainMessageHeader::CommandType::SendMessage:
+            return request_handlers[object_id - 1]->HandleSyncRequest(context);
+
+        case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {
+            LOG_DEBUG(IPC, "CloseVirtualHandle, object_id=0x%08X", object_id);
+
+            request_handlers[object_id - 1] = nullptr;
+
+            IPC::RequestBuilder rb{context, 2};
+            rb.Push(RESULT_SUCCESS);
+
+            return RESULT_SUCCESS;
+        }
+        }
+
+        LOG_CRITICAL(IPC, "Unknown domain command=%d", domain_message_header->command.Value());
+        UNIMPLEMENTED();
+    }
+    return request_handlers.front()->HandleSyncRequest(context);
+}
+
+} // namespace Kernel

src/core/hle/kernel/domain.h

@@ -0,0 +1,45 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+#include "core/hle/kernel/sync_object.h"
+#include "core/hle/result.h"
+
+namespace Kernel {
+
+class Session;
+class SessionRequestHandler;
+
+class Domain final : public SyncObject {
+public:
+    std::string GetTypeName() const override {
+        return "Domain";
+    }
+
+    static const HandleType HANDLE_TYPE = HandleType::Domain;
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
+
+    static ResultVal<SharedPtr<Domain>> CreateFromSession(const Session& server);
+
+    ResultCode SendSyncRequest(SharedPtr<Thread> thread) override;
+
+    /// The name of this domain (optional)
+    std::string name;
+
+    std::vector<std::shared_ptr<SessionRequestHandler>> request_handlers;
+
+private:
+    Domain() = default;
+    ~Domain() override = default;
+
+    static ResultVal<SharedPtr<Domain>> Create(std::string name = "Unknown");
+};
+
+} // namespace Kernel

src/core/hle/kernel/handle_table.cpp

@@ -5,10 +5,12 @@
 #include <utility>
 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "core/hle/kernel/client_session.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
+#include "core/hle/kernel/session.h"
 #include "core/hle/kernel/thread.h"
 
 namespace Kernel {
@@ -53,6 +55,14 @@ ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
     return Create(std::move(object));
 }
 
+void HandleTable::ConvertSessionToDomain(const Session& session, SharedPtr<Object> domain) {
+    for (auto& object : objects) {
+        if (DynamicObjectCast<ClientSession>(object) == session.client) {
+            object = domain;
+        }
+    }
+}
+
 ResultCode HandleTable::Close(Handle handle) {
     if (!IsValid(handle))
         return ERR_INVALID_HANDLE;

src/core/hle/kernel/handle_table.h

@@ -17,6 +17,8 @@ enum KernelHandle : Handle {
     CurrentProcess = 0xFFFF8001,
 };
 
+class Session;
+
 /**
  * This class allows the creation of Handles, which are references to objects that can be tested
  * for validity and looked up. Here they are used to pass references to kernel objects to/from the
@@ -59,6 +61,11 @@ public:
      */
     ResultVal<Handle> Duplicate(Handle handle);
 
+    /**
+     * Convert all handles of the specified Session to the specified Domain.
+     */
+    void ConvertSessionToDomain(const Session& session, SharedPtr<Object> domain);
+
     /**
      * Closes a handle, removing it from the table and decreasing the object's ref-count.
      * @return `RESULT_SUCCESS` or one of the following errors:

src/core/hle/kernel/hle_ipc.cpp

@@ -7,6 +7,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/domain.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/kernel/kernel.h"
@@ -25,6 +26,10 @@ void SessionRequestHandler::ClientDisconnected(SharedPtr<ServerSession> server_s
     boost::range::remove_erase(connected_sessions, server_session);
 }
 
+HLERequestContext::HLERequestContext(SharedPtr<Kernel::Domain> domain) : domain(std::move(domain)) {
+    cmd_buf[0] = 0;
+}
+
 HLERequestContext::HLERequestContext(SharedPtr<Kernel::ServerSession> server_session)
     : server_session(std::move(server_session)) {
     cmd_buf[0] = 0;
@@ -82,7 +87,7 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
     // Padding to align to 16 bytes
     rp.AlignWithPadding();
 
-    if (Session()->IsDomain() && (command_header->type == IPC::CommandType::Request || !incoming)) {
+    if (IsDomain() && (command_header->type == IPC::CommandType::Request || !incoming)) {
         // If this is an incoming message, only CommandType "Request" has a domain header
         // All outgoing domain messages have the domain header
         domain_message_header =
@@ -195,12 +200,12 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(u32_le* dst_cmdbuf, P
 
     // TODO(Subv): Translate the X/A/B/W buffers.
 
-    if (Session()->IsDomain()) {
+    if (IsDomain()) {
         ASSERT(domain_message_header->num_objects == domain_objects.size());
         // Write the domain objects to the command buffer, these go after the raw untranslated data.
         // TODO(Subv): This completely ignores C buffers.
         size_t domain_offset = size - domain_message_header->num_objects;
-        auto& request_handlers = server_session->domain_request_handlers;
+        auto& request_handlers = domain->request_handlers;
 
         for (auto& object : domain_objects) {
             request_handlers.emplace_back(object);

src/core/hle/kernel/hle_ipc.h

@@ -86,6 +86,7 @@ protected:
  */
 class HLERequestContext {
 public:
+    HLERequestContext(SharedPtr<Kernel::Domain> domain);
     HLERequestContext(SharedPtr<Kernel::ServerSession> session);
     ~HLERequestContext();
 
@@ -94,11 +95,18 @@ public:
         return cmd_buf.data();
     }
 
+    /**
+     * Returns the domain through which this request was made.
+     */
+    const SharedPtr<Kernel::Domain>& Domain() const {
+        return domain;
+    }
+
     /**
      * Returns the session through which this request was made. This can be used as a map key to
      * access per-client data on services.
      */
-    const SharedPtr<Kernel::ServerSession>& Session() const {
+    const SharedPtr<Kernel::ServerSession>& ServerSession() const {
         return server_session;
     }
 
@@ -143,6 +151,10 @@ public:
         return domain_message_header;
     }
 
+    bool IsDomain() const {
+        return domain != nullptr;
+    }
+
     template <typename T>
     SharedPtr<T> GetCopyObject(size_t index) {
         ASSERT(index < copy_objects.size());
@@ -175,20 +187,9 @@ public:
         domain_objects.clear();
     }
 
-    size_t NumMoveObjects() const {
-        return move_objects.size();
-    }
-
-    size_t NumCopyObjects() const {
-        return copy_objects.size();
-    }
-
-    size_t NumDomainObjects() const {
-        return domain_objects.size();
-    }
-
 private:
     std::array<u32, IPC::COMMAND_BUFFER_LENGTH> cmd_buf;
+    SharedPtr<Kernel::Domain> domain;
     SharedPtr<Kernel::ServerSession> server_session;
     // TODO(yuriks): Check common usage of this and optimize size accordingly
     boost::container::small_vector<SharedPtr<Object>, 8> move_objects;

src/core/hle/kernel/kernel.h

@@ -31,6 +31,7 @@ enum class HandleType : u32 {
     ServerPort,
     ClientSession,
     ServerSession,
+    Domain,
 };
 
 enum {
@@ -83,12 +84,27 @@ public:
         case HandleType::CodeSet:
         case HandleType::ClientPort:
         case HandleType::ClientSession:
+        case HandleType::Domain:
             return false;
         }
 
         UNREACHABLE();
     }
 
+    /**
+     * Check if svcSendSyncRequest can be called on the object
+     * @return True svcSendSyncRequest can be called on the object, otherwise false
+     */
+    bool IsSyncable() const {
+        switch (GetHandleType()) {
+        case HandleType::ClientSession:
+        case HandleType::Domain:
+            return true;
+        }
+
+        UNREACHABLE();
+    }
+
 public:
     static unsigned int next_object_id;
 

src/core/hle/kernel/mutex.cpp

@@ -70,7 +70,6 @@ ResultCode Mutex::Release(Thread* thread) {
     holding_thread->held_mutexes.erase(this);
     holding_thread->UpdatePriority();
     SetHoldingThread(nullptr);
-    SetHasWaiters(!GetWaitingThreads().empty());
     WakeupAllWaitingThreads();
     Core::System::GetInstance().PrepareReschedule();
 

src/core/hle/kernel/server_session.cpp

@@ -4,7 +4,6 @@
 
 #include <tuple>
 
-#include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
 #include "core/hle/kernel/handle_table.h"
@@ -62,38 +61,6 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
     // from its ClientSession, so wake up any threads that may be waiting on a svcReplyAndReceive or
     // similar.
 
-    Kernel::HLERequestContext context(this);
-    u32* cmd_buf = (u32*)Memory::GetPointer(thread->GetTLSAddress());
-    context.PopulateFromIncomingCommandBuffer(cmd_buf, *Kernel::g_current_process,
-                                              Kernel::g_handle_table);
-
-    // If the session has been converted to a domain, handle the doomain request
-    if (IsDomain()) {
-        auto& domain_message_header = context.GetDomainMessageHeader();
-        if (domain_message_header) {
-            // If there is a DomainMessageHeader, then this is CommandType "Request"
-            const u32 object_id{context.GetDomainMessageHeader()->object_id};
-            switch (domain_message_header->command) {
-            case IPC::DomainMessageHeader::CommandType::SendMessage:
-                return domain_request_handlers[object_id - 1]->HandleSyncRequest(context);
-
-            case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {
-                LOG_DEBUG(IPC, "CloseVirtualHandle, object_id=0x%08X", object_id);
-
-                domain_request_handlers[object_id - 1] = nullptr;
-
-                IPC::ResponseBuilder rb{context, 2};
-                rb.Push(RESULT_SUCCESS);
-                return RESULT_SUCCESS;
-            }
-            }
-
-            LOG_CRITICAL(IPC, "Unknown domain command=%d", domain_message_header->command.Value());
-            ASSERT(false);
-        }
-        // If there is no domain header, the regular session handler is used
-    }
-
     // If this ServerSession has an associated HLE handler, forward the request to it.
     ResultCode result{RESULT_SUCCESS};
     if (hle_handler != nullptr) {
@@ -102,6 +69,11 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
         if (translate_result.IsError())
             return translate_result;
 
+        Kernel::HLERequestContext context(this);
+        u32* cmd_buf = (u32*)Memory::GetPointer(Kernel::GetCurrentThread()->GetTLSAddress());
+        context.PopulateFromIncomingCommandBuffer(cmd_buf, *Kernel::g_current_process,
+                                                  Kernel::g_handle_table);
+
         result = hle_handler->HandleSyncRequest(context);
     } else {
         // Add the thread to the list of threads that have issued a sync request with this
@@ -112,15 +84,6 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
     // If this ServerSession does not have an HLE implementation, just wake up the threads waiting
     // on it.
     WakeupAllWaitingThreads();
-
-    // Handle scenario when ConvertToDomain command was issued, as we must do the conversion at the
-    // end of the command such that only commands following this one are handled as domains
-    if (convert_to_domain) {
-        ASSERT_MSG(domain_request_handlers.empty(), "already a domain");
-        domain_request_handlers = {hle_handler};
-        convert_to_domain = false;
-    }
-
     return result;
 }
 

src/core/hle/kernel/server_session.h

@@ -79,10 +79,7 @@ public:
     std::string name;                ///< The name of this session (optional)
     std::shared_ptr<Session> parent; ///< The parent session, which links to the client endpoint.
     std::shared_ptr<SessionRequestHandler>
-        hle_handler; ///< This session's HLE request handler (applicable when not a domain)
-
-    /// This is the list of domain request handlers (after conversion to a domain)
-    std::vector<std::shared_ptr<SessionRequestHandler>> domain_request_handlers;
+        hle_handler; ///< This session's HLE request handler (optional)
 
     /// List of threads that are pending a response after a sync request. This list is processed in
     /// a LIFO manner, thus, the last request will be dispatched first.
@@ -94,16 +91,6 @@ public:
     /// TODO(Subv): Find a better name for this.
     SharedPtr<Thread> currently_handling;
 
-    /// Returns true if the session has been converted to a domain, otherwise False
-    bool IsDomain() const {
-        return !domain_request_handlers.empty();
-    }
-
-    /// Converts the session to a domain at the end of the current command
-    void ConvertToDomain() {
-        convert_to_domain = true;
-    }
-
 private:
     ServerSession();
     ~ServerSession() override;
@@ -115,9 +102,6 @@ private:
      * @return The created server session
      */
     static ResultVal<SharedPtr<ServerSession>> Create(std::string name = "Unknown");
-
-    /// When set to True, converts the session to a domain at the end of the command
-    bool convert_to_domain{};
 };
 
 /**

src/core/hle/kernel/shared_memory.cpp

@@ -14,7 +14,7 @@ namespace Kernel {
 SharedMemory::SharedMemory() {}
 SharedMemory::~SharedMemory() {}
 
-SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u64 size,
+SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u32 size,
                                              MemoryPermission permissions,
                                              MemoryPermission other_permissions, VAddr address,
                                              MemoryRegion region, std::string name) {
@@ -136,8 +136,7 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
     // can not map it in its own address space unless it was created with addr=0, result 0xD900182C.
 
     if (address != 0) {
-        // TODO(shinyquagsire23): Check for virtual/mappable memory here too?
-        if (address >= Memory::HEAP_VADDR && address < Memory::HEAP_VADDR_END) {
+        if (address < Memory::HEAP_VADDR) {
             LOG_ERROR(Kernel, "cannot map id=%u, address=0x%llx name=%s, invalid address",
                       GetObjectId(), address, name.c_str());
             return ERR_INVALID_ADDRESS;

src/core/hle/kernel/shared_memory.h

@@ -39,7 +39,7 @@ public:
      * linear heap.
      * @param name Optional object name, used for debugging purposes.
      */
-    static SharedPtr<SharedMemory> Create(SharedPtr<Process> owner_process, u64 size,
+    static SharedPtr<SharedMemory> Create(SharedPtr<Process> owner_process, u32 size,
                                           MemoryPermission permissions,
                                           MemoryPermission other_permissions, VAddr address = 0,
                                           MemoryRegion region = MemoryRegion::BASE,
@@ -116,7 +116,7 @@ public:
     /// Offset into the backing block for this shared memory.
     size_t backing_block_offset;
     /// Size of the memory block. Page-aligned.
-    u64 size;
+    u32 size;
     /// Permission restrictions applied to the process which created the block.
     MemoryPermission permissions;
     /// Permission restrictions applied to other processes mapping the block.

src/core/hle/kernel/svc.cpp

@@ -20,6 +20,7 @@
 #include "core/hle/kernel/shared_memory.h"
 #include "core/hle/kernel/svc.h"
 #include "core/hle/kernel/svc_wrap.h"
+#include "core/hle/kernel/sync_object.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/lock.h"
 #include "core/hle/result.h"
@@ -86,7 +87,7 @@ static ResultCode ConnectToNamedPort(Handle* out_handle, VAddr port_name_address
 
 /// Makes a blocking IPC call to an OS service.
 static ResultCode SendSyncRequest(Handle handle) {
-    SharedPtr<ClientSession> session = g_handle_table.Get<ClientSession>(handle);
+    SharedPtr<SyncObject> session = g_handle_table.Get<SyncObject>(handle);
     if (!session) {
         LOG_ERROR(Kernel_SVC, "called with invalid handle=0x%08X", handle);
         return ERR_INVALID_HANDLE;
@@ -263,7 +264,6 @@ static ResultCode ArbitrateLock(Handle holding_thread_handle, VAddr mutex_addr,
     SharedPtr<Thread> requesting_thread = g_handle_table.Get<Thread>(requesting_thread_handle);
 
     ASSERT(requesting_thread);
-    ASSERT(requesting_thread == GetCurrentThread());
 
     SharedPtr<Mutex> mutex = g_object_address_table.Get<Mutex>(mutex_addr);
     if (!mutex) {
@@ -332,9 +332,6 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
     case GetInfoType::TotalHeapUsage:
         *result = vm_manager.GetTotalHeapUsage();
         break;
-    case GetInfoType::IsCurrentProcessBeingDebugged:
-        *result = 0;
-        break;
     case GetInfoType::RandomEntropy:
         *result = 0;
         break;
@@ -419,7 +416,8 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
               "called, shared_memory_handle=0x%08X, addr=0x%llx, size=0x%llx, permissions=0x%08X",
               shared_memory_handle, addr, size, permissions);
 
-    SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
+    SharedPtr<SharedMemory> shared_memory =
+        Kernel::g_handle_table.Get<SharedMemory>(shared_memory_handle);
     if (!shared_memory) {
         return ERR_INVALID_HANDLE;
     }
@@ -434,7 +432,7 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
     case MemoryPermission::WriteExecute:
     case MemoryPermission::ReadWriteExecute:
     case MemoryPermission::DontCare:
-        return shared_memory->Map(g_current_process.get(), addr, permissions_type,
+        return shared_memory->Map(Kernel::g_current_process.get(), addr, permissions_type,
                                   MemoryPermission::DontCare);
     default:
         LOG_ERROR(Kernel_SVC, "unknown permissions=0x%08X", permissions);
@@ -615,29 +613,20 @@ static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_var
         mutex->name = Common::StringFromFormat("mutex-%llx", mutex_addr);
     }
 
+    ASSERT(mutex->GetOwnerHandle() == thread_handle);
+
     SharedPtr<ConditionVariable> condition_variable =
         g_object_address_table.Get<ConditionVariable>(condition_variable_addr);
     if (!condition_variable) {
         // Create a new condition_variable for the specified address if one does not already exist
-        condition_variable = ConditionVariable::Create(condition_variable_addr).Unwrap();
+        condition_variable =
+            ConditionVariable::Create(condition_variable_addr, mutex_addr).Unwrap();
         condition_variable->name =
             Common::StringFromFormat("condition-variable-%llx", condition_variable_addr);
     }
 
-    if (condition_variable->mutex_addr) {
-        // Previously created the ConditionVariable using WaitProcessWideKeyAtomic, verify
-        // everything is correct
-        ASSERT(condition_variable->mutex_addr == mutex_addr);
-    } else {
-        // Previously created the ConditionVariable using SignalProcessWideKey, set the mutex
-        // associated with it
-        condition_variable->mutex_addr = mutex_addr;
-    }
-
-    if (mutex->GetOwnerHandle()) {
-        // Release the mutex if the current thread is holding it
-        mutex->Release(thread.get());
-    }
+    ASSERT(condition_variable->GetAvailableCount() == 0);
+    ASSERT(condition_variable->mutex_addr == mutex_addr);
 
     auto wakeup_callback = [mutex, nano_seconds](ThreadWakeupReason reason,
                                                  SharedPtr<Thread> thread,
@@ -679,6 +668,8 @@ static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_var
     CASCADE_CODE(
         WaitSynchronization1(condition_variable, thread.get(), nano_seconds, wakeup_callback));
 
+    mutex->Release(thread.get());
+
     return RESULT_SUCCESS;
 }
 
@@ -748,14 +739,13 @@ static ResultCode SetThreadCoreMask(u64, u64, u64) {
     return RESULT_SUCCESS;
 }
 
-static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permissions,
+static ResultCode CreateSharedMemory(Handle* handle, u64 sz, u32 local_permissions,
                                      u32 remote_permissions) {
-    LOG_TRACE(Kernel_SVC, "called, size=0x%llx, localPerms=0x%08x, remotePerms=0x%08x", size,
+    LOG_TRACE(Kernel_SVC, "called, sz=0x%llx, localPerms=0x%08x, remotePerms=0x%08x", sz,
               local_permissions, remote_permissions);
-    auto sharedMemHandle =
-        SharedMemory::Create(g_handle_table.Get<Process>(KernelHandle::CurrentProcess), size,
-                             static_cast<MemoryPermission>(local_permissions),
-                             static_cast<MemoryPermission>(remote_permissions));
+    auto sharedMemHandle = SharedMemory::Create(
+        g_handle_table.Get<Process>(KernelHandle::CurrentProcess), sz,
+        (Kernel::MemoryPermission)local_permissions, (Kernel::MemoryPermission)remote_permissions);
 
     CASCADE_RESULT(*handle, g_handle_table.Create(sharedMemHandle));
     return RESULT_SUCCESS;

src/core/hle/kernel/sync_object.h

@@ -0,0 +1,35 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <boost/smart_ptr/intrusive_ptr.hpp>
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/result.h"
+
+namespace Kernel {
+
+class Thread;
+
+/// Class that represents a Kernel object that svcSendSyncRequest can be called on
+class SyncObject : public Object {
+public:
+    /**
+     * Handle a sync request from the emulated application.
+     * @param thread Thread that initiated the request.
+     * @returns ResultCode from the operation.
+     */
+    virtual ResultCode SendSyncRequest(SharedPtr<Thread> thread) = 0;
+};
+
+// Specialization of DynamicObjectCast for SyncObjects
+template <>
+inline SharedPtr<SyncObject> DynamicObjectCast<SyncObject>(SharedPtr<Object> object) {
+    if (object != nullptr && object->IsSyncable()) {
+        return boost::static_pointer_cast<SyncObject>(std::move(object));
+    }
+    return nullptr;
+}
+
+} // namespace Kernel

src/core/hle/kernel/vm_manager.cpp

@@ -10,8 +10,8 @@
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/vm_manager.h"
 #include "core/memory.h"
-#include "core/memory_hook.h"
 #include "core/memory_setup.h"
+#include "core/mmio.h"
 
 namespace Kernel {
 
@@ -60,8 +60,8 @@ void VMManager::Reset() {
     vma_map.emplace(initial_vma.base, initial_vma);
 
     page_table.pointers.fill(nullptr);
-    page_table.special_regions.clear();
     page_table.attributes.fill(Memory::PageType::Unmapped);
+    page_table.cached_res_count.fill(0);
 
     UpdatePageTableForVMA(initial_vma);
 }
@@ -121,7 +121,7 @@ ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* me
 
 ResultVal<VMManager::VMAHandle> VMManager::MapMMIO(VAddr target, PAddr paddr, u64 size,
                                                    MemoryState state,
-                                                   Memory::MemoryHookPointer mmio_handler) {
+                                                   Memory::MMIORegionPointer mmio_handler) {
     // This is the appropriately sized VMA that will turn into our allocation.
     CASCADE_RESULT(VMAIter vma_handle, CarveVMA(target, size));
     VirtualMemoryArea& final_vma = vma_handle->second;

src/core/hle/kernel/vm_manager.h

@@ -10,7 +10,7 @@
 #include "common/common_types.h"
 #include "core/hle/result.h"
 #include "core/memory.h"
-#include "core/memory_hook.h"
+#include "core/mmio.h"
 
 namespace Kernel {
 
@@ -81,7 +81,7 @@ struct VirtualMemoryArea {
     // Settings for type = MMIO
     /// Physical address of the register area this VMA maps to.
     PAddr paddr = 0;
-    Memory::MemoryHookPointer mmio_handler = nullptr;
+    Memory::MMIORegionPointer mmio_handler = nullptr;
 
     /// Tests if this area can be merged to the right with `next`.
     bool CanBeMergedWith(const VirtualMemoryArea& next) const;
@@ -160,7 +160,7 @@ public:
      * @param mmio_handler The handler that will implement read and write for this MMIO region.
      */
     ResultVal<VMAHandle> MapMMIO(VAddr target, PAddr paddr, u64 size, MemoryState state,
-                                 Memory::MemoryHookPointer mmio_handler);
+                                 Memory::MMIORegionPointer mmio_handler);
 
     /// Unmaps a range of addresses, splitting VMAs as necessary.
     ResultCode UnmapRange(VAddr target, u64 size);

src/core/hle/service/acc/acc_u0.cpp

@@ -20,9 +20,9 @@ public:
 
 private:
     void GetBase(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
+        LOG_WARNING(Service, "(STUBBED) called");
         ProfileBase profile_base{};
-        IPC::ResponseBuilder rb{ctx, 16};
+        IPC::RequestBuilder rb{ctx, 16};
         rb.Push(RESULT_SUCCESS);
         rb.PushRaw(profile_base);
     }
@@ -30,69 +30,52 @@ private:
 
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
 public:
-    IManagerForApplication() : ServiceFramework("IManagerForApplication") {
+    IManagerForApplication() : ServiceFramework("IProfile") {
         static const FunctionInfo functions[] = {
             {0, &IManagerForApplication::CheckAvailability, "CheckAvailability"},
-            {1, &IManagerForApplication::GetAccountId, "GetAccountId"},
         };
         RegisterHandlers(functions);
     }
 
 private:
     void CheckAvailability(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 3};
+        LOG_WARNING(Service, "(STUBBED) called");
+        IPC::RequestBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push(true); // TODO: Check when this is supposed to return true and when not
     }
-
-    void GetAccountId(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(0x12345678ABCDEF);
-    }
 };
 
 void ACC_U0::GetUserExistence(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 3};
+    LOG_WARNING(Service, "(STUBBED) called");
+    IPC::RequestBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
     rb.Push(true); // TODO: Check when this is supposed to return true and when not
 }
 
 void ACC_U0::GetProfile(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<IProfile>();
-    LOG_DEBUG(Service_ACC, "called");
+    LOG_DEBUG(Service, "called");
 }
 
 void ACC_U0::InitializeApplicationInfo(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 2};
+    LOG_WARNING(Service, "(STUBBED) called");
+    IPC::RequestBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }
 
 void ACC_U0::GetBaasAccountManagerForApplication(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<IManagerForApplication>();
-    LOG_DEBUG(Service_ACC, "called");
-}
-
-void ACC_U0::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 6};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(0x0);
-    rb.Push<u64>(0x0);
+    LOG_DEBUG(Service, "called");
 }
 
 ACC_U0::ACC_U0() : ServiceFramework("acc:u0") {
     static const FunctionInfo functions[] = {
         {1, &ACC_U0::GetUserExistence, "GetUserExistence"},
-        {4, &ACC_U0::GetLastOpenedUser, "GetLastOpenedUser"},
         {5, &ACC_U0::GetProfile, "GetProfile"},
         {100, &ACC_U0::InitializeApplicationInfo, "InitializeApplicationInfo"},
         {101, &ACC_U0::GetBaasAccountManagerForApplication, "GetBaasAccountManagerForApplication"},

src/core/hle/service/acc/acc_u0.h

@@ -28,7 +28,6 @@ public:
 
 private:
     void GetUserExistence(Kernel::HLERequestContext& ctx);
-    void GetLastOpenedUser(Kernel::HLERequestContext& ctx);
     void GetProfile(Kernel::HLERequestContext& ctx);
     void InitializeApplicationInfo(Kernel::HLERequestContext& ctx);
     void GetBaasAccountManagerForApplication(Kernel::HLERequestContext& ctx);

src/core/hle/service/am/am.cpp

@@ -2,430 +2,14 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/event.h"
 #include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/am/applet_oe.h"
-#include "core/hle/service/apm/apm.h"
-#include "core/hle/service/nvflinger/nvflinger.h"
 
 namespace Service {
 namespace AM {
 
-IWindowController::IWindowController() : ServiceFramework("IWindowController") {
-    static const FunctionInfo functions[] = {
-        {1, &IWindowController::GetAppletResourceUserId, "GetAppletResourceUserId"},
-        {10, &IWindowController::AcquireForegroundRights, "AcquireForegroundRights"},
-    };
-    RegisterHandlers(functions);
-}
-
-void IWindowController::GetAppletResourceUserId(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(0);
-}
-
-void IWindowController::AcquireForegroundRights(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-IAudioController::IAudioController() : ServiceFramework("IAudioController") {}
-
-IDisplayController::IDisplayController() : ServiceFramework("IDisplayController") {}
-
-IDebugFunctions::IDebugFunctions() : ServiceFramework("IDebugFunctions") {}
-
-ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
-    : ServiceFramework("ISelfController"), nvflinger(std::move(nvflinger)) {
-    static const FunctionInfo functions[] = {
-        {1, &ISelfController::LockExit, "LockExit"},
-        {2, &ISelfController::UnlockExit, "UnlockExit"},
-        {9, &ISelfController::GetLibraryAppletLaunchableEvent, "GetLibraryAppletLaunchableEvent"},
-        {11, &ISelfController::SetOperationModeChangedNotification,
-         "SetOperationModeChangedNotification"},
-        {12, &ISelfController::SetPerformanceModeChangedNotification,
-         "SetPerformanceModeChangedNotification"},
-        {13, &ISelfController::SetFocusHandlingMode, "SetFocusHandlingMode"},
-        {14, &ISelfController::SetRestartMessageEnabled, "SetRestartMessageEnabled"},
-        {16, &ISelfController::SetOutOfFocusSuspendingEnabled, "SetOutOfFocusSuspendingEnabled"},
-        {40, &ISelfController::CreateManagedDisplayLayer, "CreateManagedDisplayLayer"},
-    };
-    RegisterHandlers(functions);
-
-    launchable_event =
-        Kernel::Event::Create(Kernel::ResetType::OneShot, "ISelfController:LaunchableEvent");
-}
-
-void ISelfController::SetFocusHandlingMode(Kernel::HLERequestContext& ctx) {
-    // Takes 3 input u8s with each field located immediately after the previous u8, these are
-    // bool flags. No output.
-
-    IPC::RequestParser rp{ctx};
-
-    struct FocusHandlingModeParams {
-        u8 unknown0;
-        u8 unknown1;
-        u8 unknown2;
-    };
-    auto flags = rp.PopRaw<FocusHandlingModeParams>();
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void ISelfController::SetRestartMessageEnabled(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void ISelfController::SetPerformanceModeChangedNotification(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-
-    bool flag = rp.Pop<bool>();
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called flag=%u", static_cast<u32>(flag));
-}
-
-void ISelfController::SetOperationModeChangedNotification(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-
-    bool flag = rp.Pop<bool>();
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called flag=%u", static_cast<u32>(flag));
-}
-
-void ISelfController::SetOutOfFocusSuspendingEnabled(Kernel::HLERequestContext& ctx) {
-    // Takes 3 input u8s with each field located immediately after the previous u8, these are
-    // bool flags. No output.
-    IPC::RequestParser rp{ctx};
-
-    bool enabled = rp.Pop<bool>();
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called enabled=%u", static_cast<u32>(enabled));
-}
-
-void ISelfController::LockExit(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void ISelfController::UnlockExit(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void ISelfController::GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx) {
-    launchable_event->Signal();
-
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(launchable_event);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void ISelfController::CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx) {
-    // TODO(Subv): Find out how AM determines the display to use, for now just create the layer
-    // in the Default display.
-    u64 display_id = nvflinger->OpenDisplay("Default");
-    u64 layer_id = nvflinger->CreateLayer(display_id);
-
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(layer_id);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-ICommonStateGetter::ICommonStateGetter() : ServiceFramework("ICommonStateGetter") {
-    static const FunctionInfo functions[] = {
-        {0, &ICommonStateGetter::GetEventHandle, "GetEventHandle"},
-        {1, &ICommonStateGetter::ReceiveMessage, "ReceiveMessage"},
-        {5, &ICommonStateGetter::GetOperationMode, "GetOperationMode"},
-        {6, &ICommonStateGetter::GetPerformanceMode, "GetPerformanceMode"},
-        {9, &ICommonStateGetter::GetCurrentFocusState, "GetCurrentFocusState"},
-    };
-    RegisterHandlers(functions);
-
-    event = Kernel::Event::Create(Kernel::ResetType::OneShot, "ICommonStateGetter:Event");
-}
-
-void ICommonStateGetter::GetEventHandle(Kernel::HLERequestContext& ctx) {
-    event->Signal();
-
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(event);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void ICommonStateGetter::ReceiveMessage(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(15);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void ICommonStateGetter::GetCurrentFocusState(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(static_cast<u8>(FocusState::InFocus));
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void ICommonStateGetter::GetOperationMode(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(static_cast<u8>(OperationMode::Handheld));
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void ICommonStateGetter::GetPerformanceMode(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(static_cast<u32>(APM::PerformanceMode::Handheld));
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-class ILibraryAppletAccessor final : public ServiceFramework<ILibraryAppletAccessor> {
-public:
-    explicit ILibraryAppletAccessor() : ServiceFramework("ILibraryAppletAccessor") {
-        static const FunctionInfo functions[] = {
-            {0, &ILibraryAppletAccessor::GetAppletStateChangedEvent, "GetAppletStateChangedEvent"},
-            {1, nullptr, "IsCompleted"},
-            {10, nullptr, "Start"},
-            {20, nullptr, "RequestExit"},
-            {25, nullptr, "Terminate"},
-            {30, nullptr, "GetResult"},
-            {50, nullptr, "SetOutOfFocusApplicationSuspendingEnabled"},
-            {100, nullptr, "PushInData"},
-            {101, nullptr, "PopOutData"},
-            {102, nullptr, "PushExtraStorage"},
-            {103, nullptr, "PushInteractiveInData"},
-            {104, nullptr, "PopInteractiveOutData"},
-            {105, nullptr, "GetPopOutDataEvent"},
-            {106, nullptr, "GetPopInteractiveOutDataEvent"},
-            {120, nullptr, "NeedsToExitProcess"},
-            {120, nullptr, "GetLibraryAppletInfo"},
-            {150, nullptr, "RequestForAppletToGetForeground"},
-            {160, nullptr, "GetIndirectLayerConsumerHandle"},
-        };
-        RegisterHandlers(functions);
-
-        state_changed_event = Kernel::Event::Create(Kernel::ResetType::OneShot,
-                                                    "ILibraryAppletAccessor:StateChangedEvent");
-    }
-
-private:
-    void GetAppletStateChangedEvent(Kernel::HLERequestContext& ctx) {
-        state_changed_event->Signal();
-
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(state_changed_event);
-
-        LOG_WARNING(Service_AM, "(STUBBED) called");
-    }
-
-    Kernel::SharedPtr<Kernel::Event> state_changed_event;
-};
-
-ILibraryAppletCreator::ILibraryAppletCreator() : ServiceFramework("ILibraryAppletCreator") {
-    static const FunctionInfo functions[] = {
-        {0, &ILibraryAppletCreator::CreateLibraryApplet, "CreateLibraryApplet"},
-        {1, nullptr, "TerminateAllLibraryApplets"},
-        {2, nullptr, "AreAnyLibraryAppletsLeft"},
-        {10, nullptr, "CreateStorage"},
-        {11, nullptr, "CreateTransferMemoryStorage"},
-        {12, nullptr, "CreateHandleStorage"},
-    };
-    RegisterHandlers(functions);
-}
-
-void ILibraryAppletCreator::CreateLibraryApplet(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<AM::ILibraryAppletAccessor>();
-
-    LOG_DEBUG(Service_AM, "called");
-}
-
-class IStorageAccessor final : public ServiceFramework<IStorageAccessor> {
-public:
-    explicit IStorageAccessor(std::vector<u8> buffer)
-        : ServiceFramework("IStorageAccessor"), buffer(std::move(buffer)) {
-        static const FunctionInfo functions[] = {
-            {0, &IStorageAccessor::GetSize, "GetSize"},
-            {11, &IStorageAccessor::Read, "Read"},
-        };
-        RegisterHandlers(functions);
-    }
-
-private:
-    std::vector<u8> buffer;
-
-    void GetSize(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 4};
-
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(static_cast<u64>(buffer.size()));
-
-        LOG_DEBUG(Service_AM, "called");
-    }
-
-    void Read(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-
-        u64 offset = rp.Pop<u64>();
-
-        const auto& output_buffer = ctx.BufferDescriptorC()[0];
-
-        ASSERT(offset + output_buffer.Size() <= buffer.size());
-
-        Memory::WriteBlock(output_buffer.Address(), buffer.data() + offset, output_buffer.Size());
-
-        IPC::ResponseBuilder rb{ctx, 2};
-
-        rb.Push(RESULT_SUCCESS);
-
-        LOG_DEBUG(Service_AM, "called");
-    }
-};
-
-class IStorage final : public ServiceFramework<IStorage> {
-public:
-    explicit IStorage(std::vector<u8> buffer)
-        : ServiceFramework("IStorage"), buffer(std::move(buffer)) {
-        static const FunctionInfo functions[] = {
-            {0, &IStorage::Open, "Open"},
-        };
-        RegisterHandlers(functions);
-    }
-
-private:
-    std::vector<u8> buffer;
-
-    void Open(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<AM::IStorageAccessor>(buffer);
-
-        LOG_DEBUG(Service_AM, "called");
-    }
-};
-
-IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationFunctions") {
-    static const FunctionInfo functions[] = {
-        {1, &IApplicationFunctions::PopLaunchParameter, "PopLaunchParameter"},
-        {20, &IApplicationFunctions::EnsureSaveData, "EnsureSaveData"},
-        {21, &IApplicationFunctions::GetDesiredLanguage, "GetDesiredLanguage"},
-        {22, &IApplicationFunctions::SetTerminateResult, "SetTerminateResult"},
-        {66, &IApplicationFunctions::InitializeGamePlayRecording, "InitializeGamePlayRecording"},
-        {67, &IApplicationFunctions::SetGamePlayRecordingState, "SetGamePlayRecordingState"},
-        {40, &IApplicationFunctions::NotifyRunning, "NotifyRunning"},
-    };
-    RegisterHandlers(functions);
-}
-
-void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
-    constexpr u8 data[0x88] = {
-        0xca, 0x97, 0x94, 0xc7, // Magic
-        1,    0,    0,    0,    // IsAccountSelected (bool)
-        1,    0,    0,    0,    // User Id (word 0)
-        0,    0,    0,    0,    // User Id (word 1)
-        0,    0,    0,    0,    // User Id (word 2)
-        0,    0,    0,    0     // User Id (word 3)
-    };
-
-    std::vector<u8> buffer(data, data + sizeof(data));
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<AM::IStorage>(buffer);
-
-    LOG_DEBUG(Service_AM, "called");
-}
-
-void IApplicationFunctions::EnsureSaveData(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void IApplicationFunctions::SetTerminateResult(Kernel::HLERequestContext& ctx) {
-    // Takes an input u32 Result, no output.
-    // For example, in some cases official apps use this with error 0x2A2 then uses svcBreak.
-
-    IPC::RequestParser rp{ctx};
-    u32 result = rp.Pop<u32>();
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called, result=0x%08X", result);
-}
-
-void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(SystemLanguage::English);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void IApplicationFunctions::InitializeGamePlayRecording(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void IApplicationFunctions::SetGamePlayRecordingState(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void IApplicationFunctions::NotifyRunning(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u8>(0); // Unknown, seems to be ignored by official processes
-
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
 void InstallInterfaces(SM::ServiceManager& service_manager,
                        std::shared_ptr<NVFlinger::NVFlinger> nvflinger) {
-    std::make_shared<AppletAE>(nvflinger)->InstallAsService(service_manager);
     std::make_shared<AppletOE>(nvflinger)->InstallAsService(service_manager);
 }
 

src/core/hle/service/am/am.h

@@ -7,10 +7,6 @@
 #include <memory>
 #include "core/hle/service/service.h"
 
-namespace Kernel {
-class Event;
-}
-
 namespace Service {
 namespace NVFlinger {
 class NVFlinger;
@@ -18,101 +14,6 @@ class NVFlinger;
 
 namespace AM {
 
-// TODO: Add more languages
-enum SystemLanguage {
-    Japanese = 0,
-    English = 1,
-};
-
-class IWindowController final : public ServiceFramework<IWindowController> {
-public:
-    IWindowController();
-
-private:
-    void GetAppletResourceUserId(Kernel::HLERequestContext& ctx);
-    void AcquireForegroundRights(Kernel::HLERequestContext& ctx);
-};
-
-class IAudioController final : public ServiceFramework<IAudioController> {
-public:
-    IAudioController();
-};
-
-class IDisplayController final : public ServiceFramework<IDisplayController> {
-public:
-    IDisplayController();
-};
-
-class IDebugFunctions final : public ServiceFramework<IDebugFunctions> {
-public:
-    IDebugFunctions();
-};
-
-class ISelfController final : public ServiceFramework<ISelfController> {
-public:
-    ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger);
-
-private:
-    void SetFocusHandlingMode(Kernel::HLERequestContext& ctx);
-    void SetRestartMessageEnabled(Kernel::HLERequestContext& ctx);
-    void SetPerformanceModeChangedNotification(Kernel::HLERequestContext& ctx);
-    void SetOperationModeChangedNotification(Kernel::HLERequestContext& ctx);
-    void SetOutOfFocusSuspendingEnabled(Kernel::HLERequestContext& ctx);
-    void LockExit(Kernel::HLERequestContext& ctx);
-    void UnlockExit(Kernel::HLERequestContext& ctx);
-    void GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx);
-    void CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx);
-
-    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
-    Kernel::SharedPtr<Kernel::Event> launchable_event;
-};
-
-class ICommonStateGetter final : public ServiceFramework<ICommonStateGetter> {
-public:
-    ICommonStateGetter();
-
-private:
-    enum class FocusState : u8 {
-        InFocus = 1,
-        NotInFocus = 2,
-    };
-
-    enum class OperationMode : u8 {
-        Handheld = 0,
-        Docked = 1,
-    };
-
-    void GetEventHandle(Kernel::HLERequestContext& ctx);
-    void ReceiveMessage(Kernel::HLERequestContext& ctx);
-    void GetCurrentFocusState(Kernel::HLERequestContext& ctx);
-    void GetOperationMode(Kernel::HLERequestContext& ctx);
-    void GetPerformanceMode(Kernel::HLERequestContext& ctx);
-
-    Kernel::SharedPtr<Kernel::Event> event;
-};
-
-class ILibraryAppletCreator final : public ServiceFramework<ILibraryAppletCreator> {
-public:
-    ILibraryAppletCreator();
-
-private:
-    void CreateLibraryApplet(Kernel::HLERequestContext& ctx);
-};
-
-class IApplicationFunctions final : public ServiceFramework<IApplicationFunctions> {
-public:
-    IApplicationFunctions();
-
-private:
-    void PopLaunchParameter(Kernel::HLERequestContext& ctx);
-    void EnsureSaveData(Kernel::HLERequestContext& ctx);
-    void SetTerminateResult(Kernel::HLERequestContext& ctx);
-    void GetDesiredLanguage(Kernel::HLERequestContext& ctx);
-    void InitializeGamePlayRecording(Kernel::HLERequestContext& ctx);
-    void SetGamePlayRecordingState(Kernel::HLERequestContext& ctx);
-    void NotifyRunning(Kernel::HLERequestContext& ctx);
-};
-
 /// Registers all AM services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager,
                        std::shared_ptr<NVFlinger::NVFlinger> nvflinger);

src/core/hle/service/am/applet_ae.cpp

@@ -1,112 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applet_ae.h"
-#include "core/hle/service/nvflinger/nvflinger.h"
-
-namespace Service {
-namespace AM {
-
-class ILibraryAppletProxy final : public ServiceFramework<ILibraryAppletProxy> {
-public:
-    ILibraryAppletProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
-        : ServiceFramework("ILibraryAppletProxy"), nvflinger(std::move(nvflinger)) {
-        static const FunctionInfo functions[] = {
-            {0, &ILibraryAppletProxy::GetCommonStateGetter, "GetCommonStateGetter"},
-            {1, &ILibraryAppletProxy::GetSelfController, "GetSelfController"},
-            {2, &ILibraryAppletProxy::GetWindowController, "GetWindowController"},
-            {3, &ILibraryAppletProxy::GetAudioController, "GetAudioController"},
-            {4, &ILibraryAppletProxy::GetDisplayController, "GetDisplayController"},
-            {11, &ILibraryAppletProxy::GetLibraryAppletCreator, "GetLibraryAppletCreator"},
-            {20, &ILibraryAppletProxy::GetApplicationFunctions, "GetApplicationFunctions"},
-            {1000, &ILibraryAppletProxy::GetDebugFunctions, "GetDebugFunctions"},
-        };
-        RegisterHandlers(functions);
-    }
-
-private:
-    void GetCommonStateGetter(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ICommonStateGetter>();
-        LOG_DEBUG(Service_AM, "called");
-    }
-
-    void GetSelfController(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ISelfController>(nvflinger);
-        LOG_DEBUG(Service_AM, "called");
-    }
-
-    void GetWindowController(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IWindowController>();
-        LOG_DEBUG(Service_AM, "called");
-    }
-
-    void GetAudioController(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IAudioController>();
-        LOG_DEBUG(Service_AM, "called");
-    }
-
-    void GetDisplayController(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IDisplayController>();
-        LOG_DEBUG(Service_AM, "called");
-    }
-
-    void GetDebugFunctions(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IDebugFunctions>();
-        LOG_DEBUG(Service_AM, "called");
-    }
-
-    void GetLibraryAppletCreator(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ILibraryAppletCreator>();
-        LOG_DEBUG(Service_AM, "called");
-    }
-
-    void GetApplicationFunctions(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IApplicationFunctions>();
-        LOG_DEBUG(Service_AM, "called");
-    }
-
-    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
-};
-
-void AppletAE::OpenLibraryAppletProxyOld(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger);
-    LOG_DEBUG(Service_AM, "called");
-}
-
-AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
-    : ServiceFramework("appletAE"), nvflinger(std::move(nvflinger)) {
-    static const FunctionInfo functions[] = {
-        {100, nullptr, "OpenSystemAppletProxy"},
-        {200, &AppletAE::OpenLibraryAppletProxyOld, "OpenLibraryAppletProxyOld"},
-        {201, nullptr, "OpenLibraryAppletProxy"},
-        {300, nullptr, "OpenOverlayAppletProxy"},
-        {350, nullptr, "OpenSystemApplicationProxy"},
-        {400, nullptr, "CreateSelfLibraryAppletCreatorForDevelop"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace AM
-} // namespace Service

src/core/hle/service/am/applet_ae.h

@@ -1,30 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace NVFlinger {
-class NVFlinger;
-}
-
-namespace AM {
-
-class AppletAE final : public ServiceFramework<AppletAE> {
-public:
-    AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger);
-    ~AppletAE() = default;
-
-private:
-    void OpenLibraryAppletProxyOld(Kernel::HLERequestContext& ctx);
-
-    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
-};
-
-} // namespace AM
-} // namespace Service

src/core/hle/service/am/applet_oe.cpp

@@ -4,13 +4,385 @@
 
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/service/am/am.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/service/am/applet_oe.h"
+#include "core/hle/service/apm/apm.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
 
 namespace Service {
 namespace AM {
 
+class IWindowController final : public ServiceFramework<IWindowController> {
+public:
+    IWindowController() : ServiceFramework("IWindowController") {
+        static const FunctionInfo functions[] = {
+            {1, &IWindowController::GetAppletResourceUserId, "GetAppletResourceUserId"},
+            {10, &IWindowController::AcquireForegroundRights, "AcquireForegroundRights"},
+        };
+        RegisterHandlers(functions);
+    }
+
+private:
+    void GetAppletResourceUserId(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service, "(STUBBED) called");
+        IPC::RequestBuilder rb{ctx, 4};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u64>(0);
+    }
+
+    void AcquireForegroundRights(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service, "(STUBBED) called");
+        IPC::RequestBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+};
+
+class IAudioController final : public ServiceFramework<IAudioController> {
+public:
+    IAudioController() : ServiceFramework("IAudioController") {}
+};
+
+class IDisplayController final : public ServiceFramework<IDisplayController> {
+public:
+    IDisplayController() : ServiceFramework("IDisplayController") {}
+};
+
+class IDebugFunctions final : public ServiceFramework<IDebugFunctions> {
+public:
+    IDebugFunctions() : ServiceFramework("IDebugFunctions") {}
+};
+
+class ISelfController final : public ServiceFramework<ISelfController> {
+public:
+    ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
+        : ServiceFramework("ISelfController"), nvflinger(std::move(nvflinger)) {
+        static const FunctionInfo functions[] = {
+            {1, &ISelfController::LockExit, "LockExit"},
+            {2, &ISelfController::UnlockExit, "UnlockExit"},
+            {11, &ISelfController::SetOperationModeChangedNotification,
+             "SetOperationModeChangedNotification"},
+            {12, &ISelfController::SetPerformanceModeChangedNotification,
+             "SetPerformanceModeChangedNotification"},
+            {13, &ISelfController::SetFocusHandlingMode, "SetFocusHandlingMode"},
+            {14, &ISelfController::SetRestartMessageEnabled, "SetRestartMessageEnabled"},
+            {16, &ISelfController::SetOutOfFocusSuspendingEnabled,
+             "SetOutOfFocusSuspendingEnabled"},
+            {40, &ISelfController::CreateManagedDisplayLayer, "CreateManagedDisplayLayer"},
+        };
+        RegisterHandlers(functions);
+    }
+
+private:
+    void SetFocusHandlingMode(Kernel::HLERequestContext& ctx) {
+        // Takes 3 input u8s with each field located immediately after the previous u8, these are
+        // bool flags. No output.
+
+        IPC::RequestParser rp{ctx};
+
+        struct FocusHandlingModeParams {
+            u8 unknown0;
+            u8 unknown1;
+            u8 unknown2;
+        };
+        auto flags = rp.PopRaw<FocusHandlingModeParams>();
+
+        IPC::RequestBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+
+        LOG_WARNING(Service, "(STUBBED) called");
+    }
+
+    void SetRestartMessageEnabled(Kernel::HLERequestContext& ctx) {
+        IPC::RequestBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+
+        LOG_WARNING(Service, "(STUBBED) called");
+    }
+
+    void SetPerformanceModeChangedNotification(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+
+        bool flag = rp.Pop<bool>();
+
+        IPC::RequestBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+
+        LOG_WARNING(Service, "(STUBBED) called flag=%u", static_cast<u32>(flag));
+    }
+
+    void SetOperationModeChangedNotification(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+
+        bool flag = rp.Pop<bool>();
+
+        IPC::RequestBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+
+        LOG_WARNING(Service, "(STUBBED) called flag=%u", static_cast<u32>(flag));
+    }
+
+    void SetOutOfFocusSuspendingEnabled(Kernel::HLERequestContext& ctx) {
+        // Takes 3 input u8s with each field located immediately after the previous u8, these are
+        // bool flags. No output.
+        IPC::RequestParser rp{ctx};
+
+        bool enabled = rp.Pop<bool>();
+
+        IPC::RequestBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+
+        LOG_WARNING(Service, "(STUBBED) called enabled=%u", static_cast<u32>(enabled));
+    }
+
+    void LockExit(Kernel::HLERequestContext& ctx) {
+        IPC::RequestBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+
+        LOG_WARNING(Service, "(STUBBED) called");
+    }
+
+    void UnlockExit(Kernel::HLERequestContext& ctx) {
+        IPC::RequestBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+
+        LOG_WARNING(Service, "(STUBBED) called");
+    }
+
+    void CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx) {
+        // TODO(Subv): Find out how AM determines the display to use, for now just create the layer
+        // in the Default display.
+        u64 display_id = nvflinger->OpenDisplay("Default");
+        u64 layer_id = nvflinger->CreateLayer(display_id);
+
+        IPC::RequestBuilder rb{ctx, 4};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(layer_id);
+
+        LOG_WARNING(Service, "(STUBBED) called");
+    }
+
+    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
+};
+
+class ICommonStateGetter final : public ServiceFramework<ICommonStateGetter> {
+public:
+    ICommonStateGetter() : ServiceFramework("ICommonStateGetter") {
+        static const FunctionInfo functions[] = {
+            {0, &ICommonStateGetter::GetEventHandle, "GetEventHandle"},
+            {1, &ICommonStateGetter::ReceiveMessage, "ReceiveMessage"},
+            {5, &ICommonStateGetter::GetOperationMode, "GetOperationMode"},
+            {6, &ICommonStateGetter::GetPerformanceMode, "GetPerformanceMode"},
+            {9, &ICommonStateGetter::GetCurrentFocusState, "GetCurrentFocusState"},
+        };
+        RegisterHandlers(functions);
+
+        event = Kernel::Event::Create(Kernel::ResetType::OneShot, "ICommonStateGetter:Event");
+    }
+
+private:
+    enum class FocusState : u8 {
+        InFocus = 1,
+        NotInFocus = 2,
+    };
+
+    enum class OperationMode : u8 {
+        Handheld = 0,
+        Docked = 1,
+    };
+
+    void GetEventHandle(Kernel::HLERequestContext& ctx) {
+        event->Signal();
+
+        IPC::RequestBuilder rb{ctx, 2, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushCopyObjects(event);
+
+        LOG_WARNING(Service, "(STUBBED) called");
+    }
+
+    void ReceiveMessage(Kernel::HLERequestContext& ctx) {
+        IPC::RequestBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u32>(15);
+
+        LOG_WARNING(Service, "(STUBBED) called");
+    }
+
+    void GetCurrentFocusState(Kernel::HLERequestContext& ctx) {
+        IPC::RequestBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(static_cast<u8>(FocusState::InFocus));
+
+        LOG_WARNING(Service, "(STUBBED) called");
+    }
+
+    void GetOperationMode(Kernel::HLERequestContext& ctx) {
+        IPC::RequestBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(static_cast<u8>(OperationMode::Handheld));
+
+        LOG_WARNING(Service, "(STUBBED) called");
+    }
+
+    void GetPerformanceMode(Kernel::HLERequestContext& ctx) {
+        IPC::RequestBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(static_cast<u32>(APM::PerformanceMode::Handheld));
+
+        LOG_WARNING(Service, "(STUBBED) called");
+    }
+
+    Kernel::SharedPtr<Kernel::Event> event;
+};
+
+class IStorageAccessor final : public ServiceFramework<IStorageAccessor> {
+public:
+    explicit IStorageAccessor(std::vector<u8> buffer)
+        : ServiceFramework("IStorageAccessor"), buffer(std::move(buffer)) {
+        static const FunctionInfo functions[] = {
+            {0, &IStorageAccessor::GetSize, "GetSize"},
+            {11, &IStorageAccessor::Read, "Read"},
+        };
+        RegisterHandlers(functions);
+    }
+
+private:
+    std::vector<u8> buffer;
+
+    void GetSize(Kernel::HLERequestContext& ctx) {
+        IPC::RequestBuilder rb{ctx, 4};
+
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(static_cast<u64>(buffer.size()));
+
+        LOG_DEBUG(Service, "called");
+    }
+
+    void Read(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+
+        u64 offset = rp.Pop<u64>();
+
+        const auto& output_buffer = ctx.BufferDescriptorC()[0];
+
+        ASSERT(offset + output_buffer.Size() <= buffer.size());
+
+        Memory::WriteBlock(output_buffer.Address(), buffer.data() + offset, output_buffer.Size());
+
+        IPC::RequestBuilder rb{ctx, 2};
+
+        rb.Push(RESULT_SUCCESS);
+
+        LOG_DEBUG(Service, "called");
+    }
+};
+
+class IStorage final : public ServiceFramework<IStorage> {
+public:
+    explicit IStorage(std::vector<u8> buffer)
+        : ServiceFramework("IStorage"), buffer(std::move(buffer)) {
+        static const FunctionInfo functions[] = {
+            {0, &IStorage::Open, "Open"},
+        };
+        RegisterHandlers(functions);
+    }
+
+private:
+    std::vector<u8> buffer;
+
+    void Open(Kernel::HLERequestContext& ctx) {
+        IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
+
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<AM::IStorageAccessor>(buffer);
+
+        LOG_DEBUG(Service, "called");
+    }
+};
+
+class IApplicationFunctions final : public ServiceFramework<IApplicationFunctions> {
+public:
+    IApplicationFunctions() : ServiceFramework("IApplicationFunctions") {
+        static const FunctionInfo functions[] = {
+            {1, &IApplicationFunctions::PopLaunchParameter, "PopLaunchParameter"},
+            {21, &IApplicationFunctions::GetDesiredLanguage, "GetDesiredLanguage"},
+            {22, &IApplicationFunctions::SetTerminateResult, "SetTerminateResult"},
+            {66, &IApplicationFunctions::InitializeGamePlayRecording,
+             "InitializeGamePlayRecording"},
+            {67, &IApplicationFunctions::SetGamePlayRecordingState, "SetGamePlayRecordingState"},
+            {40, &IApplicationFunctions::NotifyRunning, "NotifyRunning"},
+        };
+        RegisterHandlers(functions);
+    }
+
+private:
+    void PopLaunchParameter(Kernel::HLERequestContext& ctx) {
+        constexpr u8 data[0x88] = {
+            0xca, 0x97, 0x94, 0xc7, // Magic
+            1,    0,    0,    0,    // IsAccountSelected (bool)
+            1,    0,    0,    0,    // User Id (word 0)
+            0,    0,    0,    0,    // User Id (word 1)
+            0,    0,    0,    0,    // User Id (word 2)
+            0,    0,    0,    0     // User Id (word 3)
+        };
+
+        std::vector<u8> buffer(data, data + sizeof(data));
+
+        IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
+
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<AM::IStorage>(buffer);
+
+        LOG_DEBUG(Service, "called");
+    }
+
+    void SetTerminateResult(Kernel::HLERequestContext& ctx) {
+        // Takes an input u32 Result, no output.
+        // For example, in some cases official apps use this with error 0x2A2 then uses svcBreak.
+
+        IPC::RequestParser rp{ctx};
+        u32 result = rp.Pop<u32>();
+
+        IPC::RequestBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+
+        LOG_WARNING(Service, "(STUBBED) called, result=0x%08X", result);
+    }
+
+    void GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
+        IPC::RequestBuilder rb{ctx, 4};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u64>(SystemLanguage::English);
+        LOG_WARNING(Service, "(STUBBED) called");
+    }
+
+    void InitializeGamePlayRecording(Kernel::HLERequestContext& ctx) {
+        IPC::RequestBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_WARNING(Service, "(STUBBED) called");
+    }
+
+    void SetGamePlayRecordingState(Kernel::HLERequestContext& ctx) {
+        IPC::RequestBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+
+        LOG_WARNING(Service, "(STUBBED) called");
+    }
+
+    void NotifyRunning(Kernel::HLERequestContext& ctx) {
+        IPC::RequestBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u8>(0); // Unknown, seems to be ignored by official processes
+
+        LOG_WARNING(Service, "(STUBBED) called");
+    }
+};
+
+class ILibraryAppletCreator final : public ServiceFramework<ILibraryAppletCreator> {
+public:
+    ILibraryAppletCreator() : ServiceFramework("ILibraryAppletCreator") {}
+};
+
 class IApplicationProxy final : public ServiceFramework<IApplicationProxy> {
 public:
     IApplicationProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
@@ -30,69 +402,69 @@ public:
 
 private:
     void GetAudioController(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
         rb.Push(RESULT_SUCCESS);
         rb.PushIpcInterface<IAudioController>();
-        LOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service, "called");
     }
 
     void GetDisplayController(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
         rb.Push(RESULT_SUCCESS);
         rb.PushIpcInterface<IDisplayController>();
-        LOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service, "called");
     }
 
     void GetDebugFunctions(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
         rb.Push(RESULT_SUCCESS);
         rb.PushIpcInterface<IDebugFunctions>();
-        LOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service, "called");
     }
 
     void GetWindowController(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
         rb.Push(RESULT_SUCCESS);
         rb.PushIpcInterface<IWindowController>();
-        LOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service, "called");
     }
 
     void GetSelfController(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
         rb.Push(RESULT_SUCCESS);
         rb.PushIpcInterface<ISelfController>(nvflinger);
-        LOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service, "called");
     }
 
     void GetCommonStateGetter(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
         rb.Push(RESULT_SUCCESS);
         rb.PushIpcInterface<ICommonStateGetter>();
-        LOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service, "called");
     }
 
     void GetLibraryAppletCreator(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
         rb.Push(RESULT_SUCCESS);
         rb.PushIpcInterface<ILibraryAppletCreator>();
-        LOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service, "called");
     }
 
     void GetApplicationFunctions(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
         rb.Push(RESULT_SUCCESS);
         rb.PushIpcInterface<IApplicationFunctions>();
-        LOG_DEBUG(Service_AM, "called");
+        LOG_DEBUG(Service, "called");
     }
 
     std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
 };
 
 void AppletOE::OpenApplicationProxy(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<IApplicationProxy>(nvflinger);
-    LOG_DEBUG(Service_AM, "called");
+    LOG_DEBUG(Service, "called");
 }
 
 AppletOE::AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)

src/core/hle/service/am/applet_oe.h

@@ -15,6 +15,12 @@ class NVFlinger;
 
 namespace AM {
 
+// TODO: Add more languages
+enum SystemLanguage {
+    Japanese = 0,
+    English = 1,
+};
+
 class AppletOE final : public ServiceFramework<AppletOE> {
 public:
     AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger);

src/core/hle/service/apm/apm.cpp

@@ -30,11 +30,10 @@ private:
         auto mode = static_cast<PerformanceMode>(rp.Pop<u32>());
         u32 config = rp.Pop<u32>();
 
-        IPC::ResponseBuilder rb{ctx, 2};
+        IPC::RequestBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
 
-        LOG_WARNING(Service_APM, "(STUBBED) called mode=%u config=%u", static_cast<u32>(mode),
-                    config);
+        LOG_WARNING(Service, "(STUBBED) called mode=%u config=%u", static_cast<u32>(mode), config);
     }
 
     void GetPerformanceConfiguration(Kernel::HLERequestContext& ctx) {
@@ -42,11 +41,11 @@ private:
 
         auto mode = static_cast<PerformanceMode>(rp.Pop<u32>());
 
-        IPC::ResponseBuilder rb{ctx, 3};
+        IPC::RequestBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(0); // Performance configuration
 
-        LOG_WARNING(Service_APM, "(STUBBED) called mode=%u", static_cast<u32>(mode));
+        LOG_WARNING(Service, "(STUBBED) called mode=%u", static_cast<u32>(mode));
     }
 };
 
@@ -59,7 +58,7 @@ APM::APM() : ServiceFramework("apm") {
 }
 
 void APM::OpenSession(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<ISession>();
 }

src/core/hle/service/audio/audout_u.cpp

@@ -23,7 +23,7 @@ constexpr u64 audio_ticks{static_cast<u64>(BASE_CLOCK_RATE / 500)};
 
 class IAudioOut final : public ServiceFramework<IAudioOut> {
 public:
-    IAudioOut() : ServiceFramework("IAudioOut"), audio_out_state(AudioState::Stopped) {
+    IAudioOut() : ServiceFramework("IAudioOut"), audio_out_state(Stopped) {
         static const FunctionInfo functions[] = {
             {0x0, nullptr, "GetAudioOutState"},
             {0x1, &IAudioOut::StartAudioOut, "StartAudioOut"},
@@ -58,29 +58,29 @@ private:
     void StartAudioOut(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
 
-        // Start audio
-        audio_out_state = AudioState::Started;
+        // start audio
+        audio_out_state = Started;
 
-        IPC::ResponseBuilder rb{ctx, 2};
+        IPC::RequestBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
     }
 
     void StopAudioOut(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
 
-        // Stop audio
-        audio_out_state = AudioState::Stopped;
+        // stop audio
+        audio_out_state = Stopped;
 
         queue_keys.clear();
 
-        IPC::ResponseBuilder rb{ctx, 2};
+        IPC::RequestBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
     }
 
     void RegisterBufferEvent(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
 
-        IPC::ResponseBuilder rb{ctx, 2, 1};
+        IPC::RequestBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
         rb.PushCopyObjects(buffer_event);
     }
@@ -89,10 +89,11 @@ private:
         LOG_WARNING(Service_Audio, "(STUBBED) called");
         IPC::RequestParser rp{ctx};
 
-        const u64 key{rp.Pop<u64>()};
+        u64 key = rp.Pop<u64>();
+
         queue_keys.insert(queue_keys.begin(), key);
 
-        IPC::ResponseBuilder rb{ctx, 2};
+        IPC::RequestBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
     }
 
@@ -101,10 +102,11 @@ private:
 
         const auto& buffer = ctx.BufferDescriptorB()[0];
 
-        // TODO(st4rk): This is how libtransistor currently implements the
-        // GetReleasedAudioOutBuffer, it should return the key (a VAddr) to the app and this address
+        // TODO(st4rk): this is how libtransistor currently implements the
+        // GetReleasedAudioOutBuffer, it should return the key (a VAddr) to the APP and this address
         // is used to know which buffer should be filled with data and send again to the service
         // through AppendAudioOutBuffer. Check if this is the proper way to do it.
+
         u64 key{0};
 
         if (queue_keys.size()) {
@@ -114,7 +116,7 @@ private:
 
         Memory::WriteBlock(buffer.Address(), &key, sizeof(u64));
 
-        IPC::ResponseBuilder rb{ctx, 3};
+        IPC::RequestBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         // TODO(st4rk): This might be the total of released buffers, needs to be verified on
         // hardware
@@ -122,7 +124,8 @@ private:
     }
 
     void UpdateAudioBuffersCallback() {
-        if (audio_out_state != AudioState::Started) {
+
+        if (audio_out_state != Started) {
             return;
         }
 
@@ -133,7 +136,7 @@ private:
         buffer_event->Signal();
     }
 
-    enum class AudioState : u32 {
+    enum AudioState : u32 {
         Started,
         Stopped,
     };
@@ -145,10 +148,10 @@ private:
     /// This is the evend handle used to check if the audio buffer was released
     Kernel::SharedPtr<Kernel::Event> buffer_event;
 
-    /// (st4rk): This is just a temporary workaround for the future implementation. Libtransistor
+    /// (st4rk): this is just a temporary workaround for the future implementation. Libtransistor
     /// uses the key as an address in the App, so we need to return when the
     /// GetReleasedAudioOutBuffer_1 is called, otherwise we'll run in problems, because
-    /// libtransistor uses the key returned as an pointer.
+    /// libtransistor uses the key returned as an pointer;
     std::vector<u64> queue_keys;
 
     AudioState audio_out_state;
@@ -163,12 +166,14 @@ void AudOutU::ListAudioOuts(Kernel::HLERequestContext& ctx) {
 
     Memory::WriteBlock(buffer.Address(), &audio_interface[0], audio_interface.size());
 
-    IPC::ResponseBuilder rb = rp.MakeBuilder(3, 0, 0);
+    IPC::RequestBuilder rb = rp.MakeBuilder(3, 0, 0, 0);
 
     rb.Push(RESULT_SUCCESS);
-    // TODO(st4rk): We're currently returning only one audio interface (stringlist size). However,
-    // it's highly possible to have more than one interface (despite that libtransistor requires
-    // only one).
+    // TODO(st4rk): we're currently returning only one audio interface
+    // (stringlist size)
+    // however, it's highly possible to have more than one interface (despite that
+    // libtransistor
+    // requires only one).
     rb.Push<u32>(1);
 }
 
@@ -179,13 +184,20 @@ void AudOutU::OpenAudioOut(Kernel::HLERequestContext& ctx) {
         audio_out_interface = std::make_shared<IAudioOut>();
     }
 
-    IPC::ResponseBuilder rb{ctx, 6, 0, 1};
+    auto sessions = Kernel::ServerSession::CreateSessionPair(audio_out_interface->GetServiceName());
+    auto server = std::get<Kernel::SharedPtr<Kernel::ServerSession>>(sessions);
+    auto client = std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions);
+    audio_out_interface->ClientConnected(server);
+    LOG_DEBUG(Service, "called, initialized IAudioOut -> session=%u", client->GetObjectId());
+    IPC::RequestBuilder rb{ctx, 6, 0, 1};
+
     rb.Push(RESULT_SUCCESS);
     rb.Push<u32>(sample_rate);
     rb.Push<u32>(audio_channels);
     rb.Push<u32>(static_cast<u32>(PcmFormat::Int16));
-    rb.Push<u32>(0); // This field is unknown
-    rb.PushIpcInterface<Audio::IAudioOut>(audio_out_interface);
+    // this field is unknown
+    rb.Push<u32>(0);
+    rb.PushMoveObjects(std::move(client));
 }
 
 AudOutU::AudOutU() : ServiceFramework("audout:u") {

src/core/hle/service/audio/audren_u.cpp

@@ -4,7 +4,6 @@
 
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/audio/audren_u.h"
 
@@ -19,69 +18,27 @@ public:
             {0x1, nullptr, "GetAudioRendererSampleCount"},
             {0x2, nullptr, "GetAudioRendererMixBufferCount"},
             {0x3, nullptr, "GetAudioRendererState"},
-            {0x4, &IAudioRenderer::RequestUpdateAudioRenderer, "RequestUpdateAudioRenderer"},
+            {0x4, nullptr, "RequestUpdateAudioRenderer"},
             {0x5, nullptr, "StartAudioRenderer"},
             {0x6, nullptr, "StopAudioRenderer"},
-            {0x7, &IAudioRenderer::QuerySystemEvent, "QuerySystemEvent"},
+            {0x7, nullptr, "QuerySystemEvent"},
             {0x8, nullptr, "SetAudioRendererRenderingTimeLimit"},
             {0x9, nullptr, "GetAudioRendererRenderingTimeLimit"},
         };
         RegisterHandlers(functions);
-
-        system_event =
-            Kernel::Event::Create(Kernel::ResetType::OneShot, "IAudioRenderer:SystemEvent");
     }
     ~IAudioRenderer() = default;
-
-private:
-    void RequestUpdateAudioRenderer(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-
-        rb.Push(RESULT_SUCCESS);
-
-        LOG_WARNING(Service_Audio, "(STUBBED) called");
-    }
-
-    void QuerySystemEvent(Kernel::HLERequestContext& ctx) {
-        // system_event->Signal();
-
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(system_event);
-
-        LOG_WARNING(Service_Audio, "(STUBBED) called");
-    }
-
-    Kernel::SharedPtr<Kernel::Event> system_event;
 };
 
 AudRenU::AudRenU() : ServiceFramework("audren:u") {
     static const FunctionInfo functions[] = {
-        {0x00000000, &AudRenU::OpenAudioRenderer, "OpenAudioRenderer"},
-        {0x00000001, &AudRenU::GetAudioRendererWorkBufferSize, "GetAudioRendererWorkBufferSize"},
+        {0x00000000, nullptr, "OpenAudioRenderer"},
+        {0x00000001, nullptr, "GetAudioRendererWorkBufferSize"},
         {0x00000002, nullptr, "GetAudioRenderersProcessMasterVolume"},
         {0x00000003, nullptr, "SetAudioRenderersProcessMasterVolume"},
     };
     RegisterHandlers(functions);
 }
 
-void AudRenU::OpenAudioRenderer(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<Audio::IAudioRenderer>();
-
-    LOG_DEBUG(Service_Audio, "called");
-}
-
-void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 4};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(0x1000);
-
-    LOG_WARNING(Service_Audio, "called");
-}
-
 } // namespace Audio
 } // namespace Service

src/core/hle/service/audio/audren_u.h

@@ -17,10 +17,6 @@ class AudRenU final : public ServiceFramework<AudRenU> {
 public:
     explicit AudRenU();
     ~AudRenU() = default;
-
-private:
-    void OpenAudioRenderer(Kernel::HLERequestContext& ctx);
-    void GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Audio

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -40,12 +40,12 @@ private:
         // Error checking
         ASSERT_MSG(length == descriptor.Size(), "unexpected size difference");
         if (length < 0) {
-            IPC::ResponseBuilder rb{ctx, 2};
+            IPC::RequestBuilder rb{ctx, 2};
             rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidLength));
             return;
         }
         if (offset < 0) {
-            IPC::ResponseBuilder rb{ctx, 2};
+            IPC::RequestBuilder rb{ctx, 2};
             rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidOffset));
             return;
         }
@@ -54,7 +54,7 @@ private:
         std::vector<u8> output(length);
         ResultVal<size_t> res = backend->Read(offset, length, output.data());
         if (res.Failed()) {
-            IPC::ResponseBuilder rb{ctx, 2};
+            IPC::RequestBuilder rb{ctx, 2};
             rb.Push(res.Code());
             return;
         }
@@ -62,7 +62,7 @@ private:
         // Write the data to memory
         Memory::WriteBlock(descriptor.Address(), output.data(), descriptor.Size());
 
-        IPC::ResponseBuilder rb{ctx, 2};
+        IPC::RequestBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
     }
 };
@@ -71,7 +71,6 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
     static const FunctionInfo functions[] = {
         {1, &FSP_SRV::Initalize, "Initalize"},
         {200, &FSP_SRV::OpenDataStorageByCurrentProcess, "OpenDataStorageByCurrentProcess"},
-        {202, nullptr, "OpenDataStorageByDataId"},
         {203, &FSP_SRV::OpenRomStorage, "OpenRomStorage"},
         {1005, &FSP_SRV::GetGlobalAccessLogMode, "GetGlobalAccessLogMode"},
     };
@@ -92,14 +91,14 @@ void FSP_SRV::TryLoadRomFS() {
 void FSP_SRV::Initalize(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_FS, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 2};
+    IPC::RequestBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }
 
 void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_FS, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 3};
+    IPC::RequestBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
     rb.Push<u32>(5);
 }
@@ -111,7 +110,7 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
     if (!romfs) {
         // TODO (bunnei): Find the right error code to use here
         LOG_CRITICAL(Service_FS, "no file system interface available!");
-        IPC::ResponseBuilder rb{ctx, 2};
+        IPC::RequestBuilder rb{ctx, 2};
         rb.Push(ResultCode(-1));
         return;
     }
@@ -120,12 +119,12 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
     auto storage = romfs->OpenFile({}, {});
     if (storage.Failed()) {
         LOG_CRITICAL(Service_FS, "no storage interface available!");
-        IPC::ResponseBuilder rb{ctx, 2};
+        IPC::RequestBuilder rb{ctx, 2};
         rb.Push(storage.Code());
         return;
     }
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<IStorage>(std::move(storage.Unwrap()));
 }

src/core/hle/service/hid/hid.cpp

@@ -9,7 +9,6 @@
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
-#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/shared_memory.h"
 #include "core/hle/service/hid/hid.h"
 #include "core/hle/service/service.h"
@@ -47,10 +46,10 @@ public:
 
 private:
     void GetSharedMemoryHandle(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 1};
+        IPC::RequestBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
         rb.PushCopyObjects(shared_mem);
-        LOG_DEBUG(Service_HID, "called");
+        LOG_DEBUG(Service, "called");
     }
 
     void LoadInputDevices() {
@@ -152,131 +151,37 @@ private:
         buttons;
 };
 
-class IActiveVibrationDeviceList final : public ServiceFramework<IActiveVibrationDeviceList> {
-public:
-    IActiveVibrationDeviceList() : ServiceFramework("IActiveVibrationDeviceList") {
-        static const FunctionInfo functions[] = {
-            {0, &IActiveVibrationDeviceList::ActivateVibrationDevice, "ActivateVibrationDevice"},
-        };
-        RegisterHandlers(functions);
-    }
-
-private:
-    void ActivateVibrationDevice(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-};
-
 class Hid final : public ServiceFramework<Hid> {
 public:
     Hid() : ServiceFramework("hid") {
         static const FunctionInfo functions[] = {
-            {0, &Hid::CreateAppletResource, "CreateAppletResource"},
-            {1, &Hid::ActivateDebugPad, "ActivateDebugPad"},
-            {11, &Hid::ActivateTouchScreen, "ActivateTouchScreen"},
-            {66, &Hid::StartSixAxisSensor, "StartSixAxisSensor"},
-            {100, &Hid::SetSupportedNpadStyleSet, "SetSupportedNpadStyleSet"},
-            {102, &Hid::SetSupportedNpadIdType, "SetSupportedNpadIdType"},
-            {103, &Hid::ActivateNpad, "ActivateNpad"},
-            {106, &Hid::AcquireNpadStyleSetUpdateEventHandle,
-             "AcquireNpadStyleSetUpdateEventHandle"},
-            {120, &Hid::SetNpadJoyHoldType, "SetNpadJoyHoldType"},
-            {121, &Hid::GetNpadJoyHoldType, "GetNpadJoyHoldType"},
-            {124, nullptr, "SetNpadJoyAssignmentModeDual"},
-            {128, &Hid::SetNpadHandheldActivationMode, "SetNpadHandheldActivationMode"},
-            {203, &Hid::CreateActiveVibrationDeviceList, "CreateActiveVibrationDeviceList"},
+            {0x00000000, &Hid::CreateAppletResource, "CreateAppletResource"},
         };
         RegisterHandlers(functions);
-
-        event = Kernel::Event::Create(Kernel::ResetType::OneShot, "hid:EventHandle");
     }
     ~Hid() = default;
 
 private:
     std::shared_ptr<IAppletResource> applet_resource;
-    u32 joy_hold_type{0};
-    Kernel::SharedPtr<Kernel::Event> event;
 
     void CreateAppletResource(Kernel::HLERequestContext& ctx) {
         if (applet_resource == nullptr) {
             applet_resource = std::make_shared<IAppletResource>();
         }
 
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IAppletResource>(applet_resource);
-        LOG_DEBUG(Service_HID, "called");
-    }
+        // TODO(Subv): Verify if this should return the interface as a domain object when called
+        // from within a domain.
 
-    void ActivateDebugPad(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
+        auto sessions = Kernel::ServerSession::CreateSessionPair(applet_resource->GetServiceName());
+        auto server = std::get<Kernel::SharedPtr<Kernel::ServerSession>>(sessions);
+        auto client = std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions);
+        applet_resource->ClientConnected(server);
 
-    void ActivateTouchScreen(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
+        LOG_DEBUG(Service, "called, initialized IAppletResource -> session=%u",
+                  client->GetObjectId());
+        IPC::RequestBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
-    void StartSixAxisSensor(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
-    void SetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
-    void SetSupportedNpadIdType(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
-    void ActivateNpad(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
-    void AcquireNpadStyleSetUpdateEventHandle(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(event);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
-    void SetNpadJoyHoldType(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
-    void GetNpadJoyHoldType(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(joy_hold_type);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
-    void SetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
-    void CreateActiveVibrationDeviceList(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IActiveVibrationDeviceList>();
-        LOG_DEBUG(Service_HID, "called");
+        rb.PushMoveObjects(std::move(client));
     }
 };
 

src/core/hle/service/lm/lm.cpp

@@ -65,7 +65,7 @@ private:
      */
     void Log(Kernel::HLERequestContext& ctx) {
         // This function only succeeds - Get that out of the way
-        IPC::ResponseBuilder rb{ctx, 2};
+        IPC::RequestBuilder rb{ctx, 1};
         rb.Push(RESULT_SUCCESS);
 
         // Read MessageHeader, despite not doing anything with it right now
@@ -76,7 +76,7 @@ private:
         addr += sizeof(MessageHeader);
 
         if (!header.IsSingleMessage()) {
-            LOG_WARNING(Service_LM, "Multi message logs are unimplemeneted");
+            LOG_WARNING(Service, "Multi message logs are unimplemeneted");
             return;
         }
 
@@ -125,12 +125,12 @@ private:
         if (line) {
             output += std::to_string(line) + ':';
         }
-        if (output.length() > 0 && output.back() == ':') {
+        if (output.back() == ':') {
             output += ' ';
         }
         output += message;
 
-        LOG_INFO(Debug_Emulated, "%s", output.c_str());
+        LOG_DEBUG(Debug_Emulated, "%s", output.c_str());
     }
 };
 
@@ -146,11 +146,21 @@ void InstallInterfaces(SM::ServiceManager& service_manager) {
  *      0: ResultCode
  */
 void LM::Initialize(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<Logger>();
+    // TODO(Subv): Verify if this should return the interface as a domain object when called from
+    // within a domain.
 
-    LOG_DEBUG(Service_LM, "called");
+    auto logger = std::make_shared<Logger>();
+    auto sessions = Kernel::ServerSession::CreateSessionPair(logger->GetServiceName());
+    auto server = std::get<Kernel::SharedPtr<Kernel::ServerSession>>(sessions);
+    auto client = std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions);
+    logger->ClientConnected(server);
+
+    LOG_DEBUG(Service_SM, "called, initialized logger -> session=%u", client->GetObjectId());
+    IPC::RequestBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushMoveObjects(std::move(client));
+
+    LOG_INFO(Service_SM, "called");
 }
 
 LM::LM() : ServiceFramework("lm") {

src/core/hle/service/nifm/nifm.cpp

@@ -1,161 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/nifm/nifm.h"
-#include "core/hle/service/nifm/nifm_a.h"
-#include "core/hle/service/nifm/nifm_s.h"
-#include "core/hle/service/nifm/nifm_u.h"
-
-namespace Service {
-namespace NIFM {
-
-class IScanRequest final : public ServiceFramework<IScanRequest> {
-public:
-    explicit IScanRequest() : ServiceFramework("IScanRequest") {
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "Submit"},
-            {1, nullptr, "IsProcessing"},
-            {2, nullptr, "GetResult"},
-            {3, nullptr, "GetSystemEventReadableHandle"},
-        };
-        RegisterHandlers(functions);
-    }
-};
-
-class IRequest final : public ServiceFramework<IRequest> {
-public:
-    explicit IRequest() : ServiceFramework("IRequest") {
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetRequestState"},
-            {1, nullptr, "GetResult"},
-            {2, nullptr, "GetSystemEventReadableHandles"},
-            {3, nullptr, "Cancel"},
-            {4, nullptr, "Submit"},
-            {5, nullptr, "SetRequirement"},
-            {6, nullptr, "SetRequirementPreset"},
-            {8, nullptr, "SetPriority"},
-            {9, nullptr, "SetNetworkProfileId"},
-            {10, nullptr, "SetRejectable"},
-            {11, nullptr, "SetConnectionConfirmationOption"},
-            {12, nullptr, "SetPersistent"},
-            {13, nullptr, "SetInstant"},
-            {14, nullptr, "SetSustainable"},
-            {15, nullptr, "SetRawPriority"},
-            {16, nullptr, "SetGreedy"},
-            {17, nullptr, "SetSharable"},
-            {18, nullptr, "SetRequirementByRevision"},
-            {19, nullptr, "GetRequirement"},
-            {20, nullptr, "GetRevision"},
-            {21, nullptr, "GetAppletInfo"},
-            {22, nullptr, "GetAdditionalInfo"},
-            {23, nullptr, "SetKeptInSleep"},
-            {24, nullptr, "RegisterSocketDescriptor"},
-            {25, nullptr, "UnregisterSocketDescriptor"},
-        };
-        RegisterHandlers(functions);
-    }
-};
-
-class INetworkProfile final : public ServiceFramework<INetworkProfile> {
-public:
-    explicit INetworkProfile() : ServiceFramework("INetworkProfile") {
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "Update"},
-            {1, nullptr, "PersistOld"},
-            {2, nullptr, "Persist"},
-        };
-        RegisterHandlers(functions);
-    }
-};
-
-IGeneralService::IGeneralService() : ServiceFramework("IGeneralService") {
-    static const FunctionInfo functions[] = {
-        {1, &IGeneralService::GetClientId, "GetClientId"},
-        {2, &IGeneralService::CreateScanRequest, "CreateScanRequest"},
-        {4, &IGeneralService::CreateRequest, "CreateRequest"},
-        {6, nullptr, "GetCurrentNetworkProfile"},
-        {7, nullptr, "EnumerateNetworkInterfaces"},
-        {8, nullptr, "GetNetworkProfile"},
-        {9, nullptr, "SetNetworkProfile"},
-        {10, &IGeneralService::RemoveNetworkProfile, "RemoveNetworkProfile"},
-        {11, nullptr, "GetScanDataOld"},
-        {12, nullptr, "GetCurrentIpAddress"},
-        {13, nullptr, "GetCurrentAccessPointOld"},
-        {14, &IGeneralService::CreateTemporaryNetworkProfile, "CreateTemporaryNetworkProfile"},
-        {15, nullptr, "GetCurrentIpConfigInfo"},
-        {16, nullptr, "SetWirelessCommunicationEnabled"},
-        {17, nullptr, "IsWirelessCommunicationEnabled"},
-        {18, nullptr, "GetInternetConnectionStatus"},
-        {19, nullptr, "SetEthernetCommunicationEnabled"},
-        {20, nullptr, "IsEthernetCommunicationEnabled"},
-        {21, nullptr, "IsAnyInternetRequestAccepted"},
-        {22, nullptr, "IsAnyForegroundRequestAccepted"},
-        {23, nullptr, "PutToSleep"},
-        {24, nullptr, "WakeUp"},
-        {25, nullptr, "GetSsidListVersion"},
-        {26, nullptr, "SetExclusiveClient"},
-        {27, nullptr, "GetDefaultIpSetting"},
-        {28, nullptr, "SetDefaultIpSetting"},
-        {29, nullptr, "SetWirelessCommunicationEnabledForTest"},
-        {30, nullptr, "SetEthernetCommunicationEnabledForTest"},
-        {31, nullptr, "GetTelemetorySystemEventReadableHandle"},
-        {32, nullptr, "GetTelemetryInfo"},
-        {33, nullptr, "ConfirmSystemAvailability"},
-        {34, nullptr, "SetBackgroundRequestEnabled"},
-        {35, nullptr, "GetScanData"},
-        {36, nullptr, "GetCurrentAccessPoint"},
-        {37, nullptr, "Shutdown"},
-    };
-    RegisterHandlers(functions);
-}
-
-void IGeneralService::GetClientId(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_NIFM, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(0);
-}
-
-void IGeneralService::CreateScanRequest(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IScanRequest>();
-
-    LOG_DEBUG(Service_NIFM, "called");
-}
-
-void IGeneralService::CreateRequest(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IRequest>();
-
-    LOG_DEBUG(Service_NIFM, "called");
-}
-
-void IGeneralService::RemoveNetworkProfile(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_NIFM, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void IGeneralService::CreateTemporaryNetworkProfile(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<INetworkProfile>();
-
-    LOG_DEBUG(Service_NIFM, "called");
-}
-
-void InstallInterfaces(SM::ServiceManager& service_manager) {
-    std::make_shared<NIFM_A>()->InstallAsService(service_manager);
-    std::make_shared<NIFM_S>()->InstallAsService(service_manager);
-    std::make_shared<NIFM_U>()->InstallAsService(service_manager);
-}
-
-} // namespace NIFM
-} // namespace Service

src/core/hle/service/nifm/nifm.h

@@ -1,27 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace NIFM {
-
-class IGeneralService final : public ServiceFramework<IGeneralService> {
-public:
-    IGeneralService();
-
-private:
-    void GetClientId(Kernel::HLERequestContext& ctx);
-    void CreateScanRequest(Kernel::HLERequestContext& ctx);
-    void CreateRequest(Kernel::HLERequestContext& ctx);
-    void RemoveNetworkProfile(Kernel::HLERequestContext& ctx);
-    void CreateTemporaryNetworkProfile(Kernel::HLERequestContext& ctx);
-};
-
-void InstallInterfaces(SM::ServiceManager& service_manager);
-
-} // namespace NIFM
-} // namespace Service

src/core/hle/service/nifm/nifm_a.cpp

@@ -1,36 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/nifm/nifm.h"
-#include "core/hle/service/nifm/nifm_a.h"
-
-namespace Service {
-namespace NIFM {
-
-void NIFM_A::CreateGeneralServiceOld(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IGeneralService>();
-    LOG_DEBUG(Service_NIFM, "called");
-}
-
-void NIFM_A::CreateGeneralService(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IGeneralService>();
-    LOG_DEBUG(Service_NIFM, "called");
-}
-
-NIFM_A::NIFM_A() : ServiceFramework("nifm:a") {
-    static const FunctionInfo functions[] = {
-        {4, &NIFM_A::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
-        {5, &NIFM_A::CreateGeneralService, "CreateGeneralService"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace NIFM
-} // namespace Service

src/core/hle/service/nifm/nifm_a.h

@@ -1,24 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace NIFM {
-
-class NIFM_A final : public ServiceFramework<NIFM_A> {
-public:
-    NIFM_A();
-    ~NIFM_A() = default;
-
-private:
-    void CreateGeneralServiceOld(Kernel::HLERequestContext& ctx);
-    void CreateGeneralService(Kernel::HLERequestContext& ctx);
-};
-
-} // namespace NIFM
-} // namespace Service

src/core/hle/service/nifm/nifm_s.cpp

@@ -1,36 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/nifm/nifm.h"
-#include "core/hle/service/nifm/nifm_s.h"
-
-namespace Service {
-namespace NIFM {
-
-void NIFM_S::CreateGeneralServiceOld(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IGeneralService>();
-    LOG_DEBUG(Service_NIFM, "called");
-}
-
-void NIFM_S::CreateGeneralService(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IGeneralService>();
-    LOG_DEBUG(Service_NIFM, "called");
-}
-
-NIFM_S::NIFM_S() : ServiceFramework("nifm:s") {
-    static const FunctionInfo functions[] = {
-        {4, &NIFM_S::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
-        {5, &NIFM_S::CreateGeneralService, "CreateGeneralService"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace NIFM
-} // namespace Service

src/core/hle/service/nifm/nifm_s.h

@@ -1,24 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace NIFM {
-
-class NIFM_S final : public ServiceFramework<NIFM_S> {
-public:
-    NIFM_S();
-    ~NIFM_S() = default;
-
-private:
-    void CreateGeneralServiceOld(Kernel::HLERequestContext& ctx);
-    void CreateGeneralService(Kernel::HLERequestContext& ctx);
-};
-
-} // namespace NIFM
-} // namespace Service

src/core/hle/service/nifm/nifm_u.cpp

@@ -1,36 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/nifm/nifm.h"
-#include "core/hle/service/nifm/nifm_u.h"
-
-namespace Service {
-namespace NIFM {
-
-void NIFM_U::CreateGeneralServiceOld(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IGeneralService>();
-    LOG_DEBUG(Service_NIFM, "called");
-}
-
-void NIFM_U::CreateGeneralService(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IGeneralService>();
-    LOG_DEBUG(Service_NIFM, "called");
-}
-
-NIFM_U::NIFM_U() : ServiceFramework("nifm:u") {
-    static const FunctionInfo functions[] = {
-        {4, &NIFM_U::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
-        {5, &NIFM_U::CreateGeneralService, "CreateGeneralService"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace NIFM
-} // namespace Service

src/core/hle/service/nifm/nifm_u.h

@@ -1,24 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace NIFM {
-
-class NIFM_U final : public ServiceFramework<NIFM_U> {
-public:
-    NIFM_U();
-    ~NIFM_U() = default;
-
-private:
-    void CreateGeneralServiceOld(Kernel::HLERequestContext& ctx);
-    void CreateGeneralService(Kernel::HLERequestContext& ctx);
-};
-
-} // namespace NIFM
-} // namespace Service

src/core/hle/service/nvdrv/devices/nvdevice.h

@@ -5,9 +5,7 @@
 #pragma once
 
 #include <vector>
-#include "common/bit_field.h"
 #include "common/common_types.h"
-#include "common/swap.h"
 
 namespace Service {
 namespace Nvidia {
@@ -19,14 +17,6 @@ class nvdevice {
 public:
     nvdevice() = default;
     virtual ~nvdevice() = default;
-    union Ioctl {
-        u32_le raw;
-        BitField<0, 8, u32_le> cmd;
-        BitField<8, 8, u32_le> group;
-        BitField<16, 14, u32_le> length;
-        BitField<30, 1, u32_le> is_in;
-        BitField<31, 1, u32_le> is_out;
-    };
 
     /**
      * Handles an ioctl request.
@@ -35,7 +25,7 @@ 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, std::vector<u8>& output) = 0;
+    virtual u32 ioctl(u32 command, const std::vector<u8>& input, std::vector<u8>& output) = 0;
 };
 
 } // namespace Devices

src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp

@@ -14,7 +14,7 @@ namespace Service {
 namespace Nvidia {
 namespace Devices {
 
-u32 nvdisp_disp0::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvdisp_disp0::ioctl(u32 command, const std::vector<u8>& input, std::vector<u8>& output) {
     UNIMPLEMENTED();
     return 0;
 }

src/core/hle/service/nvdrv/devices/nvdisp_disp0.h

@@ -20,7 +20,7 @@ public:
     nvdisp_disp0(std::shared_ptr<nvmap> nvmap_dev) : nvdevice(), nvmap_dev(std::move(nvmap_dev)) {}
     ~nvdisp_disp0() = default;
 
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
+    u32 ioctl(u32 command, const std::vector<u8>& input, std::vector<u8>& output) 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);

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp

@@ -5,107 +5,13 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/hle/service/nvdrv/devices/nvhost_as_gpu.h"
-#include "core/hle/service/nvdrv/devices/nvmap.h"
 
 namespace Service {
 namespace Nvidia {
 namespace Devices {
 
-u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    LOG_DEBUG(Service_NVDRV, "called, command=0x%08x, input_size=0x%llx, output_size=0x%llx",
-              command, input.size(), output.size());
-
-    switch (static_cast<IoctlCommand>(command.raw)) {
-    case IoctlCommand::IocInitalizeExCommand:
-        return InitalizeEx(input, output);
-    case IoctlCommand::IocAllocateSpaceCommand:
-        return AllocateSpace(input, output);
-    case IoctlCommand::IocMapBufferExCommand:
-        return MapBufferEx(input, output);
-    case IoctlCommand::IocBindChannelCommand:
-        return BindChannel(input, output);
-    case IoctlCommand::IocGetVaRegionsCommand:
-        return GetVARegions(input, output);
-    }
-    return 0;
-}
-
-u32 nvhost_as_gpu::InitalizeEx(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlInitalizeEx params{};
-    std::memcpy(&params, input.data(), input.size());
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called, big_page_size=0x%x", params.big_page_size);
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
-u32 nvhost_as_gpu::AllocateSpace(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlAllocSpace params{};
-    std::memcpy(&params, input.data(), input.size());
-    LOG_DEBUG(Service_NVDRV, "called, pages=%x, page_size=%x, flags=%x", params.pages,
-              params.page_size, params.flags);
-
-    const u64 size{static_cast<u64>(params.pages) * static_cast<u64>(params.page_size)};
-    if (params.flags & 1) {
-        params.offset = memory_manager->AllocateSpace(params.offset, size, 1);
-    } else {
-        params.offset = memory_manager->AllocateSpace(size, params.align);
-    }
-
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
-u32 nvhost_as_gpu::MapBufferEx(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlMapBufferEx params{};
-    std::memcpy(&params, input.data(), input.size());
-
-    LOG_DEBUG(Service_NVDRV,
-              "called, flags=%x, nvmap_handle=%x, buffer_offset=%lx, mapping_size=%lx, offset=%lx",
-              params.flags, params.nvmap_handle, params.buffer_offset, params.mapping_size,
-              params.offset);
-
-    if (!params.nvmap_handle) {
-        return 0;
-    }
-
-    auto object = nvmap_dev->GetObject(params.nvmap_handle);
-    ASSERT(object);
-
-    if (params.flags & 1) {
-        params.offset = memory_manager->MapBufferEx(object->addr, params.offset, object->size);
-    } else {
-        params.offset = memory_manager->MapBufferEx(object->addr, object->size);
-    }
-
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
-u32 nvhost_as_gpu::BindChannel(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlBindChannel params{};
-    std::memcpy(&params, input.data(), input.size());
-    LOG_DEBUG(Service_NVDRV, "called, fd=%x", params.fd);
-    channel = params.fd;
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
-u32 nvhost_as_gpu::GetVARegions(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlGetVaRegions params{};
-    std::memcpy(&params, input.data(), input.size());
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called, buf_addr=%lx, buf_size=%x", params.buf_addr,
-                params.buf_size);
-
-    params.buf_size = 0x30;
-    params.regions[0].offset = 0x04000000;
-    params.regions[0].page_size = 0x1000;
-    params.regions[0].pages = 0x3fbfff;
-
-    params.regions[1].offset = 0x04000000;
-    params.regions[1].page_size = 0x10000;
-    params.regions[1].pages = 0x1bffff;
-    // TODO(ogniK): This probably can stay stubbed but should add support way way later
-    std::memcpy(output.data(), &params, output.size());
+u32 nvhost_as_gpu::ioctl(u32 command, const std::vector<u8>& input, std::vector<u8>& output) {
+    UNIMPLEMENTED();
     return 0;
 }
 

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h

@@ -4,104 +4,20 @@
 
 #pragma once
 
-#include <memory>
-#include <utility>
 #include <vector>
 #include "common/common_types.h"
-#include "common/swap.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"
-#include "core/hle/service/nvdrv/memory_manager.h"
 
 namespace Service {
 namespace Nvidia {
 namespace Devices {
 
-class nvmap;
-
 class nvhost_as_gpu final : public nvdevice {
 public:
-    nvhost_as_gpu(std::shared_ptr<nvmap> nvmap_dev) : nvdevice(), nvmap_dev(std::move(nvmap_dev)) {
-        memory_manager = std::make_shared<MemoryManager>();
-    }
+    nvhost_as_gpu() = default;
     ~nvhost_as_gpu() override = default;
 
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-
-private:
-    enum class IoctlCommand : u32_le {
-        IocInitalizeExCommand = 0x40284109,
-        IocAllocateSpaceCommand = 0xC0184102,
-        IocMapBufferExCommand = 0xC0284106,
-        IocBindChannelCommand = 0x40044101,
-        IocGetVaRegionsCommand = 0xC0404108,
-    };
-
-    struct IoctlInitalizeEx {
-        u32_le big_page_size; // depends on GPU's available_big_page_sizes; 0=default
-        s32_le as_fd;         // ignored; passes 0
-        u32_le flags;         // passes 0
-        u32_le reserved;      // ignored; passes 0
-        u64_le unk0;
-        u64_le unk1;
-        u64_le unk2;
-    };
-    static_assert(sizeof(IoctlInitalizeEx) == 40, "IoctlInitalizeEx is incorrect size");
-
-    struct IoctlAllocSpace {
-        u32_le pages;
-        u32_le page_size;
-        u32_le flags;
-        INSERT_PADDING_WORDS(1);
-        union {
-            u64_le offset;
-            u64_le align;
-        };
-    };
-    static_assert(sizeof(IoctlAllocSpace) == 24, "IoctlInitalizeEx is incorrect size");
-
-    struct IoctlMapBufferEx {
-        u32_le flags; // bit0: fixed_offset, bit2: cacheable
-        u32_le kind;  // -1 is default
-        u32_le nvmap_handle;
-        u32_le page_size; // 0 means don't care
-        u64_le buffer_offset;
-        u64_le mapping_size;
-        u64_le offset;
-    };
-    static_assert(sizeof(IoctlMapBufferEx) == 40, "IoctlMapBufferEx is incorrect size");
-
-    struct IoctlBindChannel {
-        u32_le fd;
-    };
-    static_assert(sizeof(IoctlBindChannel) == 4, "IoctlBindChannel is incorrect size");
-
-    struct IoctlVaRegion {
-        u64_le offset;
-        u32_le page_size;
-        INSERT_PADDING_WORDS(1);
-        u64_le pages;
-    };
-    static_assert(sizeof(IoctlVaRegion) == 24, "IoctlVaRegion is incorrect size");
-
-    struct IoctlGetVaRegions {
-        u64_le buf_addr; // (contained output user ptr on linux, ignored)
-        u32_le buf_size; // forced to 2*sizeof(struct va_region)
-        u32_le reserved;
-        IoctlVaRegion regions[2];
-    };
-    static_assert(sizeof(IoctlGetVaRegions) == 16 + sizeof(IoctlVaRegion) * 2,
-                  "IoctlGetVaRegions is incorrect size");
-
-    u32 channel{};
-
-    u32 InitalizeEx(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 AllocateSpace(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 MapBufferEx(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 BindChannel(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 GetVARegions(const std::vector<u8>& input, std::vector<u8>& output);
-
-    std::shared_ptr<nvmap> nvmap_dev;
-    std::shared_ptr<MemoryManager> memory_manager;
+    u32 ioctl(u32 command, const std::vector<u8>& input, std::vector<u8>& output) override;
 };
 
 } // namespace Devices

src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp

@@ -10,12 +10,12 @@ namespace Service {
 namespace Nvidia {
 namespace Devices {
 
-u32 nvhost_ctrl::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
+u32 nvhost_ctrl::ioctl(u32 command, const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_DEBUG(Service_NVDRV, "called, command=0x%08x, input_size=0x%lx, output_size=0x%lx", command,
               input.size(), output.size());
 
-    switch (static_cast<IoctlCommand>(command.raw)) {
-    case IoctlCommand::IocGetConfigCommand:
+    switch (command) {
+    case IocGetConfigCommand:
         return NvOsGetConfigU32(input, output);
     }
     UNIMPLEMENTED();
@@ -23,23 +23,19 @@ u32 nvhost_ctrl::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<
 }
 
 u32 nvhost_ctrl::NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output) {
-    IocGetConfigParams params{};
+    IocGetConfigParams params;
     std::memcpy(&params, input.data(), sizeof(params));
     LOG_DEBUG(Service_NVDRV, "called, setting=%s!%s", params.domain_str.data(),
               params.param_str.data());
 
     if (!strcmp(params.domain_str.data(), "nv")) {
         if (!strcmp(params.param_str.data(), "NV_MEMORY_PROFILER")) {
-            params.config_str[0] = '0';
-        } else if (!strcmp(params.param_str.data(), "NVN_THROUGH_OPENGL")) {
-            params.config_str[0] = '0';
-        } else if (!strcmp(params.param_str.data(), "NVRM_GPU_PREVENT_USE")) {
-            params.config_str[0] = '0';
+            params.config_str[0] = '1';
         } else {
-            params.config_str[0] = '0';
+            UNIMPLEMENTED();
         }
     } else {
-        UNIMPLEMENTED(); // unknown domain? Only nv has been seen so far on hardware
+        UNIMPLEMENTED();
     }
     std::memcpy(output.data(), &params, sizeof(params));
     return 0;

src/core/hle/service/nvdrv/devices/nvhost_ctrl.h

@@ -20,10 +20,10 @@ public:
     nvhost_ctrl() = default;
     ~nvhost_ctrl() override = default;
 
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
+    u32 ioctl(u32 command, const std::vector<u8>& input, std::vector<u8>& output) override;
 
 private:
-    enum class IoctlCommand : u32_le {
+    enum IoctlCommands {
         IocSyncptReadCommand = 0xC0080014,
         IocSyncptIncrCommand = 0x40040015,
         IocSyncptWaitCommand = 0xC00C0016,
@@ -39,7 +39,6 @@ private:
         std::array<char, 0x41> param_str;
         std::array<char, 0x101> config_str;
     };
-    static_assert(sizeof(IocGetConfigParams) == 387, "IocGetConfigParams is incorrect size");
 
     u32 NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output);
 };

src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp

@@ -1,114 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h"
-
-namespace Service {
-namespace Nvidia {
-namespace Devices {
-
-u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    LOG_DEBUG(Service_NVDRV, "called, command=0x%08x, input_size=0x%llx, output_size=0x%llx",
-              command, input.size(), output.size());
-
-    switch (static_cast<IoctlCommand>(command.raw)) {
-    case IoctlCommand::IocGetCharacteristicsCommand:
-        return GetCharacteristics(input, output);
-    case IoctlCommand::IocGetTPCMasksCommand:
-        return GetTPCMasks(input, output);
-    case IoctlCommand::IocGetActiveSlotMaskCommand:
-        return GetActiveSlotMask(input, output);
-    case IoctlCommand::IocZcullGetCtxSizeCommand:
-        return ZCullGetCtxSize(input, output);
-    case IoctlCommand::IocZcullGetInfo:
-        return ZCullGetInfo(input, output);
-    }
-    UNIMPLEMENTED();
-    return 0;
-}
-
-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());
-    params.gc.arch = 0x120;
-    params.gc.impl = 0xb;
-    params.gc.rev = 0xa1;
-    params.gc.num_gpc = 0x1;
-    params.gc.l2_cache_size = 0x40000;
-    params.gc.on_board_video_memory_size = 0x0;
-    params.gc.num_tpc_per_gpc = 0x2;
-    params.gc.bus_type = 0x20;
-    params.gc.big_page_size = 0x20000;
-    params.gc.compression_page_size = 0x20000;
-    params.gc.pde_coverage_bit_count = 0x1B;
-    params.gc.available_big_page_sizes = 0x30000;
-    params.gc.gpc_mask = 0x1;
-    params.gc.sm_arch_sm_version = 0x503;
-    params.gc.sm_arch_spa_version = 0x503;
-    params.gc.sm_arch_warp_count = 0x80;
-    params.gc.gpu_va_bit_count = 0x28;
-    params.gc.reserved = 0x0;
-    params.gc.flags = 0x55;
-    params.gc.twod_class = 0x902D;
-    params.gc.threed_class = 0xB197;
-    params.gc.compute_class = 0xB1C0;
-    params.gc.gpfifo_class = 0xB06F;
-    params.gc.inline_to_memory_class = 0xA140;
-    params.gc.dma_copy_class = 0xB0B5;
-    params.gc.max_fbps_count = 0x1;
-    params.gc.fbp_en_mask = 0x0;
-    params.gc.max_ltc_per_fbp = 0x2;
-    params.gc.max_lts_per_ltc = 0x1;
-    params.gc.max_tex_per_tpc = 0x0;
-    params.gc.max_gpc_count = 0x1;
-    params.gc.rop_l2_en_mask_0 = 0x21D70;
-    params.gc.rop_l2_en_mask_1 = 0x0;
-    params.gc.chipname = 0x6230326D67;
-    params.gc.gr_compbit_store_base_hw = 0x0;
-    params.gpu_characteristics_buf_size = 0xA0;
-    params.gpu_characteristics_buf_addr = 0xdeadbeef; // Cannot be 0 (UNUSED)
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
-u32 nvhost_ctrl_gpu::GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlGpuGetTpcMasksArgs params{};
-    std::memcpy(&params, input.data(), input.size());
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called, mask=0x%x, mask_buf_addr=0x%lx",
-                params.mask_buf_size, params.mask_buf_addr);
-    std::memcpy(output.data(), &params, sizeof(params));
-    return 0;
-}
-
-u32 nvhost_ctrl_gpu::GetActiveSlotMask(const std::vector<u8>& input, std::vector<u8>& output) {
-    LOG_DEBUG(Service_NVDRV, "called");
-    IoctlActiveSlotMask params{};
-    std::memcpy(&params, input.data(), input.size());
-    params.slot = 0x07;
-    params.mask = 0x01;
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
-u32 nvhost_ctrl_gpu::ZCullGetCtxSize(const std::vector<u8>& input, std::vector<u8>& output) {
-    LOG_DEBUG(Service_NVDRV, "called");
-    IoctlZcullGetCtxSize params{};
-    std::memcpy(&params, input.data(), input.size());
-    params.size = 0x1;
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
-u32 nvhost_ctrl_gpu::ZCullGetInfo(const std::vector<u8>& input, std::vector<u8>& output) {
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
-    std::memset(output.data(), 0, output.size());
-    return 0;
-}
-
-} // namespace Devices
-} // namespace Nvidia
-} // namespace Service

src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h

@@ -1,130 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/service/nvdrv/devices/nvdevice.h"
-
-namespace Service {
-namespace Nvidia {
-namespace Devices {
-
-class nvhost_ctrl_gpu final : public nvdevice {
-public:
-    nvhost_ctrl_gpu() = default;
-    ~nvhost_ctrl_gpu() override = default;
-
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-
-private:
-    enum class IoctlCommand : u32_le {
-        IocGetCharacteristicsCommand = 0xC0B04705,
-        IocGetTPCMasksCommand = 0xC0184706,
-        IocGetActiveSlotMaskCommand = 0x80084714,
-        IocZcullGetCtxSizeCommand = 0x80044701,
-        IocZcullGetInfo = 0x80284702,
-    };
-
-    struct IoctlGpuCharacteristics {
-        u32_le arch;                       // 0x120 (NVGPU_GPU_ARCH_GM200)
-        u32_le impl;                       // 0xB (NVGPU_GPU_IMPL_GM20B)
-        u32_le rev;                        // 0xA1 (Revision A1)
-        u32_le num_gpc;                    // 0x1
-        u64_le l2_cache_size;              // 0x40000
-        u64_le on_board_video_memory_size; // 0x0 (not used)
-        u32_le num_tpc_per_gpc;            // 0x2
-        u32_le bus_type;                   // 0x20 (NVGPU_GPU_BUS_TYPE_AXI)
-        u32_le big_page_size;              // 0x20000
-        u32_le compression_page_size;      // 0x20000
-        u32_le pde_coverage_bit_count;     // 0x1B
-        u32_le available_big_page_sizes;   // 0x30000
-        u32_le gpc_mask;                   // 0x1
-        u32_le sm_arch_sm_version;         // 0x503 (Maxwell Generation 5.0.3?)
-        u32_le sm_arch_spa_version;        // 0x503 (Maxwell Generation 5.0.3?)
-        u32_le sm_arch_warp_count;         // 0x80
-        u32_le gpu_va_bit_count;           // 0x28
-        u32_le reserved;                   // NULL
-        u64_le flags;                      // 0x55
-        u32_le twod_class;                 // 0x902D (FERMI_TWOD_A)
-        u32_le threed_class;               // 0xB197 (MAXWELL_B)
-        u32_le compute_class;              // 0xB1C0 (MAXWELL_COMPUTE_B)
-        u32_le gpfifo_class;               // 0xB06F (MAXWELL_CHANNEL_GPFIFO_A)
-        u32_le inline_to_memory_class;     // 0xA140 (KEPLER_INLINE_TO_MEMORY_B)
-        u32_le dma_copy_class;             // 0xB0B5 (MAXWELL_DMA_COPY_A)
-        u32_le max_fbps_count;             // 0x1
-        u32_le fbp_en_mask;                // 0x0 (disabled)
-        u32_le max_ltc_per_fbp;            // 0x2
-        u32_le max_lts_per_ltc;            // 0x1
-        u32_le max_tex_per_tpc;            // 0x0 (not supported)
-        u32_le max_gpc_count;              // 0x1
-        u32_le rop_l2_en_mask_0;           // 0x21D70 (fuse_status_opt_rop_l2_fbp_r)
-        u32_le rop_l2_en_mask_1;           // 0x0
-        u64_le chipname;                   // 0x6230326D67 ("gm20b")
-        u64_le gr_compbit_store_base_hw;   // 0x0 (not supported)
-    };
-    static_assert(sizeof(IoctlGpuCharacteristics) == 160,
-                  "IoctlGpuCharacteristics is incorrect size");
-
-    struct IoctlCharacteristics {
-        u64_le gpu_characteristics_buf_size; // must not be NULL, but gets overwritten with
-                                             // 0xA0=max_size
-        u64_le gpu_characteristics_buf_addr; // ignored, but must not be NULL
-        IoctlGpuCharacteristics gc;
-    };
-    static_assert(sizeof(IoctlCharacteristics) == 16 + sizeof(IoctlGpuCharacteristics),
-                  "IoctlCharacteristics is incorrect size");
-
-    struct IoctlGpuGetTpcMasksArgs {
-        /// [in]  TPC mask buffer size reserved by userspace. Should be at least
-        /// sizeof(__u32) * fls(gpc_mask) to receive TPC mask for each GPC.
-        /// [out] full kernel buffer size
-        u32_le mask_buf_size;
-        u32_le reserved;
-
-        /// [in]  pointer to TPC mask buffer. It will receive one 32-bit TPC mask per GPC or 0 if
-        /// GPC is not enabled or not present. This parameter is ignored if mask_buf_size is 0.
-        u64_le mask_buf_addr;
-        u64_le unk; // Nintendo add this?
-    };
-    static_assert(sizeof(IoctlGpuGetTpcMasksArgs) == 24,
-                  "IoctlGpuGetTpcMasksArgs is incorrect size");
-
-    struct IoctlActiveSlotMask {
-        u32_le slot; // always 0x07
-        u32_le mask;
-    };
-    static_assert(sizeof(IoctlActiveSlotMask) == 8, "IoctlActiveSlotMask is incorrect size");
-
-    struct IoctlZcullGetCtxSize {
-        u32_le size;
-    };
-    static_assert(sizeof(IoctlZcullGetCtxSize) == 4, "IoctlZcullGetCtxSize is incorrect size");
-
-    struct IoctlNvgpuGpuZcullGetInfoArgs {
-        u32_le width_align_pixels;
-        u32_le height_align_pixels;
-        u32_le pixel_squares_by_aliquots;
-        u32_le aliquot_total;
-        u32_le region_byte_multiplier;
-        u32_le region_header_size;
-        u32_le subregion_header_size;
-        u32_le subregion_width_align_pixels;
-        u32_le subregion_height_align_pixels;
-        u32_le subregion_count;
-    };
-    static_assert(sizeof(IoctlNvgpuGpuZcullGetInfoArgs) == 40,
-                  "IoctlNvgpuGpuZcullGetInfoArgs is incorrect size");
-
-    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);
-    u32 ZCullGetInfo(const std::vector<u8>& input, std::vector<u8>& output);
-};
-} // namespace Devices
-} // namespace Nvidia
-} // namespace Service

src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp

@@ -1,144 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <map>
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "core/hle/service/nvdrv/devices/nvhost_gpu.h"
-
-namespace Service {
-namespace Nvidia {
-namespace Devices {
-
-u32 nvhost_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    LOG_DEBUG(Service_NVDRV, "called, command=0x%08x, input_size=0x%llx, output_size=0x%llx",
-              command, input.size(), output.size());
-
-    switch (static_cast<IoctlCommand>(command.raw)) {
-    case IoctlCommand::IocSetNVMAPfdCommand:
-        return SetNVMAPfd(input, output);
-    case IoctlCommand::IocSetClientDataCommand:
-        return SetClientData(input, output);
-    case IoctlCommand::IocGetClientDataCommand:
-        return GetClientData(input, output);
-    case IoctlCommand::IocZCullBind:
-        return ZCullBind(input, output);
-    case IoctlCommand::IocSetErrorNotifierCommand:
-        return SetErrorNotifier(input, output);
-    case IoctlCommand::IocChannelSetPriorityCommand:
-        return SetChannelPriority(input, output);
-    case IoctlCommand::IocAllocGPFIFOEx2Command:
-        return AllocGPFIFOEx2(input, output);
-    case IoctlCommand::IocAllocObjCtxCommand:
-        return AllocateObjectContext(input, output);
-    }
-
-    if (command.group == NVGPU_IOCTL_MAGIC) {
-        if (command.cmd == NVGPU_IOCTL_CHANNEL_SUBMIT_GPFIFO) {
-            return SubmitGPFIFO(input, output);
-        }
-    }
-
-    UNIMPLEMENTED();
-    return 0;
-};
-
-u32 nvhost_gpu::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlSetNvmapFD params{};
-    std::memcpy(&params, input.data(), input.size());
-    LOG_DEBUG(Service_NVDRV, "called, fd=%x", params.nvmap_fd);
-    nvmap_fd = params.nvmap_fd;
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
-u32 nvhost_gpu::SetClientData(const std::vector<u8>& input, std::vector<u8>& output) {
-    LOG_DEBUG(Service_NVDRV, "called");
-    IoctlClientData params{};
-    std::memcpy(&params, input.data(), input.size());
-    user_data = params.data;
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
-u32 nvhost_gpu::GetClientData(const std::vector<u8>& input, std::vector<u8>& output) {
-    LOG_DEBUG(Service_NVDRV, "called");
-    IoctlClientData params{};
-    std::memcpy(&params, input.data(), input.size());
-    params.data = user_data;
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
-u32 nvhost_gpu::ZCullBind(const std::vector<u8>& input, std::vector<u8>& output) {
-    std::memcpy(&zcull_params, input.data(), input.size());
-    LOG_DEBUG(Service_NVDRV, "called, gpu_va=%lx, mode=%x", zcull_params.gpu_va, zcull_params.mode);
-    std::memcpy(output.data(), &zcull_params, output.size());
-    return 0;
-}
-
-u32 nvhost_gpu::SetErrorNotifier(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlSetErrorNotifier params{};
-    std::memcpy(&params, input.data(), input.size());
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called, offset=%lx, size=%lx, mem=%x", params.offset,
-                params.size, params.mem);
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
-u32 nvhost_gpu::SetChannelPriority(const std::vector<u8>& input, std::vector<u8>& output) {
-    std::memcpy(&channel_priority, input.data(), input.size());
-    LOG_DEBUG(Service_NVDRV, "(STUBBED) called, priority=%x", channel_priority);
-    std::memcpy(output.data(), &channel_priority, output.size());
-    return 0;
-}
-
-u32 nvhost_gpu::AllocGPFIFOEx2(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlAllocGpfifoEx2 params{};
-    std::memcpy(&params, input.data(), input.size());
-    LOG_WARNING(Service_NVDRV,
-                "(STUBBED) called, num_entries=%x, flags=%x, unk0=%x, unk1=%x, unk2=%x, unk3=%x",
-                params.num_entries, params.flags, params.unk0, params.unk1, params.unk2,
-                params.unk3);
-    params.fence_out.id = 0;
-    params.fence_out.value = 0;
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
-u32 nvhost_gpu::AllocateObjectContext(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlAllocObjCtx params{};
-    std::memcpy(&params, input.data(), input.size());
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called, class_num=%x, flags=%x", params.class_num,
-                params.flags);
-    params.obj_id = 0x0;
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
-u32 nvhost_gpu::SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& output) {
-    if (input.size() < sizeof(IoctlSubmitGpfifo))
-        UNIMPLEMENTED();
-    IoctlSubmitGpfifo params{};
-    std::memcpy(&params, input.data(), sizeof(IoctlSubmitGpfifo));
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called, gpfifo=%lx, num_entries=%x, flags=%x",
-                params.gpfifo, params.num_entries, params.flags);
-
-    auto entries = std::vector<IoctlGpfifoEntry>();
-    entries.resize(params.num_entries);
-    std::memcpy(&entries[0], &input.data()[sizeof(IoctlSubmitGpfifo)],
-                params.num_entries * sizeof(IoctlGpfifoEntry));
-    for (auto entry : entries) {
-        VAddr va_addr = entry.Address();
-        // TODO(ogniK): Process these
-    }
-    params.fence_out.id = 0;
-    params.fence_out.value = 0;
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
-} // namespace Devices
-} // namespace Nvidia
-} // namespace Service

src/core/hle/service/nvdrv/devices/nvhost_gpu.h

@@ -1,139 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/service/nvdrv/devices/nvdevice.h"
-
-namespace Service {
-namespace Nvidia {
-namespace Devices {
-constexpr u32 NVGPU_IOCTL_MAGIC('H');
-constexpr u32 NVGPU_IOCTL_CHANNEL_SUBMIT_GPFIFO(0x8);
-
-class nvhost_gpu final : public nvdevice {
-public:
-    nvhost_gpu() = default;
-    ~nvhost_gpu() override = default;
-
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
-
-private:
-    enum class IoctlCommand : u32_le {
-        IocSetNVMAPfdCommand = 0x40044801,
-        IocSetClientDataCommand = 0x40084714,
-        IocGetClientDataCommand = 0x80084715,
-        IocZCullBind = 0xc010480b,
-        IocSetErrorNotifierCommand = 0xC018480C,
-        IocChannelSetPriorityCommand = 0x4004480D,
-        IocAllocGPFIFOEx2Command = 0xC020481A,
-        IocAllocObjCtxCommand = 0xC0104809,
-    };
-
-    enum class CtxObjects : u32_le {
-        Ctx2D = 0x902D,
-        Ctx3D = 0xB197,
-        CtxCompute = 0xB1C0,
-        CtxKepler = 0xA140,
-        CtxDMA = 0xB0B5,
-        CtxChannelGPFIFO = 0xB06F,
-    };
-
-    struct IoctlSetNvmapFD {
-        u32_le nvmap_fd;
-    };
-    static_assert(sizeof(IoctlSetNvmapFD) == 4, "IoctlSetNvmapFD is incorrect size");
-
-    struct IoctlClientData {
-        u64_le data;
-    };
-    static_assert(sizeof(IoctlClientData) == 8, "IoctlClientData is incorrect size");
-
-    struct IoctlZCullBind {
-        u64_le gpu_va;
-        u32_le mode; // 0=global, 1=no_ctxsw, 2=separate_buffer, 3=part_of_regular_buf
-        INSERT_PADDING_WORDS(1);
-    };
-    static_assert(sizeof(IoctlZCullBind) == 16, "IoctlZCullBind is incorrect size");
-
-    struct IoctlSetErrorNotifier {
-        u64_le offset;
-        u64_le size;
-        u32_le mem; // nvmap object handle
-        INSERT_PADDING_WORDS(1);
-    };
-    static_assert(sizeof(IoctlSetErrorNotifier) == 24, "IoctlSetErrorNotifier is incorrect size");
-
-    struct IoctlFence {
-        u32_le id;
-        u32_le value;
-    };
-    static_assert(sizeof(IoctlFence) == 8, "IoctlFence is incorrect size");
-
-    struct IoctlAllocGpfifoEx2 {
-        u32_le num_entries;   // in
-        u32_le flags;         // in
-        u32_le unk0;          // in (1 works)
-        IoctlFence fence_out; // out
-        u32_le unk1;          // in
-        u32_le unk2;          // in
-        u32_le unk3;          // in
-    };
-    static_assert(sizeof(IoctlAllocGpfifoEx2) == 32, "IoctlAllocGpfifoEx2 is incorrect size");
-
-    struct IoctlAllocObjCtx {
-        u32_le class_num; // 0x902D=2d, 0xB197=3d, 0xB1C0=compute, 0xA140=kepler, 0xB0B5=DMA,
-                          // 0xB06F=channel_gpfifo
-        u32_le flags;
-        u64_le obj_id; // (ignored) used for FREE_OBJ_CTX ioctl, which is not supported
-    };
-    static_assert(sizeof(IoctlAllocObjCtx) == 16, "IoctlAllocObjCtx is incorrect size");
-
-    struct IoctlGpfifoEntry {
-        u32_le entry0; // gpu_va_lo
-        union {
-            u32_le entry1; // gpu_va_hi | (unk_0x02 << 0x08) | (size << 0x0A) | (unk_0x01 << 0x1F)
-            BitField<0, 8, u32_le> gpu_va_hi;
-            BitField<8, 2, u32_le> unk1;
-            BitField<10, 21, u32_le> sz;
-            BitField<31, 1, u32_le> unk2;
-        };
-
-        VAddr Address() const {
-            return (static_cast<VAddr>(gpu_va_hi) << 32) | entry0;
-        }
-    };
-    static_assert(sizeof(IoctlGpfifoEntry) == 8, "IoctlGpfifoEntry is incorrect size");
-
-    struct IoctlSubmitGpfifo {
-        u64_le gpfifo;      // (ignored) pointer to gpfifo fence structs
-        u32_le num_entries; // number of fence objects being submitted
-        u32_le flags;
-        IoctlFence fence_out; // returned new fence object for others to wait on
-    };
-    static_assert(sizeof(IoctlSubmitGpfifo) == 16 + sizeof(IoctlFence),
-                  "submit_gpfifo is incorrect size");
-
-    u32_le nvmap_fd{};
-    u64_le user_data{};
-    IoctlZCullBind zcull_params{};
-    u32_le channel_priority{};
-
-    u32 SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 SetClientData(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 GetClientData(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 ZCullBind(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 SetErrorNotifier(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 SetChannelPriority(const std::vector<u8>& input, std::vector<u8>& output);
-    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);
-};
-
-} // namespace Devices
-} // namespace Nvidia
-} // namespace Service

src/core/hle/service/nvdrv/devices/nvmap.cpp

@@ -13,14 +13,16 @@ namespace Nvidia {
 namespace Devices {
 
 VAddr nvmap::GetObjectAddress(u32 handle) const {
-    auto object = GetObject(handle);
-    ASSERT(object);
+    auto itr = handles.find(handle);
+    ASSERT(itr != handles.end());
+
+    auto object = itr->second;
     ASSERT(object->status == Object::Status::Allocated);
     return object->addr;
 }
 
-u32 nvmap::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    switch (static_cast<IoctlCommand>(command.raw)) {
+u32 nvmap::ioctl(u32 command, const std::vector<u8>& input, std::vector<u8>& output) {
+    switch (static_cast<IoctlCommand>(command)) {
     case IoctlCommand::Create:
         return IocCreate(input, output);
     case IoctlCommand::Alloc:
@@ -50,7 +52,7 @@ u32 nvmap::IocCreate(const std::vector<u8>& input, std::vector<u8>& output) {
     u32 handle = next_handle++;
     handles[handle] = std::move(object);
 
-    LOG_DEBUG(Service_NVDRV, "size=0x%08X", params.size);
+    LOG_WARNING(Service, "(STUBBED) size 0x%08X", params.size);
 
     params.handle = handle;
 
@@ -62,16 +64,17 @@ u32 nvmap::IocAlloc(const std::vector<u8>& input, std::vector<u8>& output) {
     IocAllocParams params;
     std::memcpy(&params, input.data(), sizeof(params));
 
-    auto object = GetObject(params.handle);
-    ASSERT(object);
+    auto itr = handles.find(params.handle);
+    ASSERT(itr != handles.end());
 
+    auto object = itr->second;
     object->flags = params.flags;
     object->align = params.align;
     object->kind = params.kind;
     object->addr = params.addr;
     object->status = Object::Status::Allocated;
 
-    LOG_DEBUG(Service_NVDRV, "called, addr=0x%llx", params.addr);
+    LOG_WARNING(Service, "(STUBBED) Allocated address 0x%llx", params.addr);
 
     std::memcpy(output.data(), &params, sizeof(params));
     return 0;
@@ -81,12 +84,12 @@ u32 nvmap::IocGetId(const std::vector<u8>& input, std::vector<u8>& output) {
     IocGetIdParams params;
     std::memcpy(&params, input.data(), sizeof(params));
 
-    LOG_WARNING(Service_NVDRV, "called");
+    LOG_WARNING(Service, "called");
 
-    auto object = GetObject(params.handle);
-    ASSERT(object);
+    auto itr = handles.find(params.handle);
+    ASSERT(itr != handles.end());
 
-    params.id = object->id;
+    params.id = itr->second->id;
 
     std::memcpy(output.data(), &params, sizeof(params));
     return 0;
@@ -96,7 +99,7 @@ u32 nvmap::IocFromId(const std::vector<u8>& input, std::vector<u8>& output) {
     IocFromIdParams params;
     std::memcpy(&params, input.data(), sizeof(params));
 
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
 
     auto itr = std::find_if(handles.begin(), handles.end(),
                             [&](const auto& entry) { return entry.second->id == params.id; });
@@ -118,10 +121,12 @@ u32 nvmap::IocParam(const std::vector<u8>& input, std::vector<u8>& output) {
     IocParamParams params;
     std::memcpy(&params, input.data(), sizeof(params));
 
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called type=%u", params.type);
+    LOG_WARNING(Service, "(STUBBED) called type=%u", params.type);
 
-    auto object = GetObject(params.handle);
-    ASSERT(object);
+    auto itr = handles.find(params.handle);
+    ASSERT(itr != handles.end());
+
+    auto object = itr->second;
     ASSERT(object->status == Object::Status::Allocated);
 
     switch (static_cast<ParamTypes>(params.type)) {

src/core/hle/service/nvdrv/devices/nvmap.h

@@ -24,9 +24,10 @@ 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, std::vector<u8>& output) override;
+    u32 ioctl(u32 command, const std::vector<u8>& input, std::vector<u8>& output) override;
 
-    /// Represents an nvmap object.
+private:
+    // Represents an nvmap object.
     struct Object {
         enum class Status { Created, Allocated };
         u32 id;
@@ -38,19 +39,10 @@ public:
         Status status;
     };
 
-    std::shared_ptr<Object> GetObject(u32 handle) const {
-        auto itr = handles.find(handle);
-        if (itr != handles.end()) {
-            return itr->second;
-        }
-        return {};
-    }
-
-private:
     /// Id to use for the next handle that is created.
     u32 next_handle = 1;
 
-    /// Id to use for the next object that is created.
+    // Id to use for the next object that is created.
     u32 next_id = 1;
 
     /// Mapping of currently allocated handles to the objects they represent.

src/core/hle/service/nvdrv/interface.cpp

@@ -4,7 +4,6 @@
 
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/event.h"
 #include "core/hle/service/nvdrv/interface.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 
@@ -12,95 +11,72 @@ namespace Service {
 namespace Nvidia {
 
 void NVDRV::Open(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_NVDRV, "called");
+    LOG_WARNING(Service, "(STUBBED) called");
 
     auto buffer = ctx.BufferDescriptorA()[0];
 
     std::string device_name = Memory::ReadCString(buffer.Address(), buffer.Size());
 
     u32 fd = nvdrv->Open(device_name);
-    IPC::ResponseBuilder rb{ctx, 4};
+    IPC::RequestBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
     rb.Push<u32>(fd);
     rb.Push<u32>(0);
 }
 
 void NVDRV::Ioctl(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_NVDRV, "called");
+    LOG_WARNING(Service, "(STUBBED) called");
 
     IPC::RequestParser rp{ctx};
     u32 fd = rp.Pop<u32>();
     u32 command = rp.Pop<u32>();
 
-    IPC::ResponseBuilder rb{ctx, 3};
+    auto input_buffer = ctx.BufferDescriptorA()[0];
+    auto output_buffer = ctx.BufferDescriptorB()[0];
+
+    std::vector<u8> input(input_buffer.Size());
+    std::vector<u8> output(output_buffer.Size());
+
+    Memory::ReadBlock(input_buffer.Address(), input.data(), input_buffer.Size());
+
+    u32 nv_result = nvdrv->Ioctl(fd, command, input, output);
+
+    Memory::WriteBlock(output_buffer.Address(), output.data(), output_buffer.Size());
+
+    IPC::RequestBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    if (ctx.BufferDescriptorA()[0].Size() != 0) {
-        auto input_buffer = ctx.BufferDescriptorA()[0];
-        auto output_buffer = ctx.BufferDescriptorB()[0];
-        std::vector<u8> input(input_buffer.Size());
-        std::vector<u8> output(output_buffer.Size());
-        Memory::ReadBlock(input_buffer.Address(), input.data(), input_buffer.Size());
-        rb.Push(nvdrv->Ioctl(fd, command, input, output));
-        Memory::WriteBlock(output_buffer.Address(), output.data(), output_buffer.Size());
-    } else {
-        auto input_buffer = ctx.BufferDescriptorX()[0];
-        auto output_buffer = ctx.BufferDescriptorC()[0];
-        std::vector<u8> input(input_buffer.size);
-        std::vector<u8> output(output_buffer.size);
-        Memory::ReadBlock(input_buffer.Address(), input.data(), input_buffer.size);
-        rb.Push(nvdrv->Ioctl(fd, command, input, output));
-        Memory::WriteBlock(output_buffer.Address(), output.data(), output_buffer.size);
-    }
+    rb.Push(nv_result);
 }
 
 void NVDRV::Close(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_NVDRV, "called");
+    LOG_WARNING(Service, "(STUBBED) called");
 
     IPC::RequestParser rp{ctx};
     u32 fd = rp.Pop<u32>();
 
     auto result = nvdrv->Close(fd);
 
-    IPC::ResponseBuilder rb{ctx, 2};
+    IPC::RequestBuilder rb{ctx, 2};
     rb.Push(result);
 }
 
 void NVDRV::Initialize(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 3};
+    LOG_WARNING(Service, "(STUBBED) called");
+    IPC::RequestBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
     rb.Push<u32>(0);
 }
 
-void NVDRV::QueryEvent(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    u32 fd = rp.Pop<u32>();
-    u32 event_id = rp.Pop<u32>();
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called, fd=%x, event_id=%x", fd, event_id);
-
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(RESULT_SUCCESS);
-    auto event = Kernel::Event::Create(Kernel::ResetType::Pulse, "NVEvent");
-    event->Signal();
-    rb.PushCopyObjects(event);
-}
-
 void NVDRV::SetClientPID(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     pid = rp.Pop<u64>();
 
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called, pid=0x%lx", pid);
-    IPC::ResponseBuilder rb{ctx, 3};
+    LOG_INFO(Service, "called, pid=0x%lx", pid);
+    IPC::RequestBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
     rb.Push<u32>(0);
 }
 
-void NVDRV::FinishInitialize(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
 NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
     : ServiceFramework(name), nvdrv(std::move(nvdrv)) {
     static const FunctionInfo functions[] = {
@@ -108,9 +84,7 @@ NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
         {1, &NVDRV::Ioctl, "Ioctl"},
         {2, &NVDRV::Close, "Close"},
         {3, &NVDRV::Initialize, "Initialize"},
-        {4, &NVDRV::QueryEvent, "QueryEvent"},
         {8, &NVDRV::SetClientPID, "SetClientPID"},
-        {13, &NVDRV::FinishInitialize, "FinishInitialize"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/nvdrv/interface.h

@@ -22,9 +22,7 @@ private:
     void Ioctl(Kernel::HLERequestContext& ctx);
     void Close(Kernel::HLERequestContext& ctx);
     void Initialize(Kernel::HLERequestContext& ctx);
-    void QueryEvent(Kernel::HLERequestContext& ctx);
     void SetClientPID(Kernel::HLERequestContext& ctx);
-    void FinishInitialize(Kernel::HLERequestContext& ctx);
 
     std::shared_ptr<Module> nvdrv;
 

src/core/hle/service/nvdrv/memory_manager.cpp

@@ -1,112 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "core/hle/service/nvdrv/memory_manager.h"
-
-namespace Service {
-namespace Nvidia {
-
-PAddr MemoryManager::AllocateSpace(u64 size, u64 align) {
-    boost::optional<PAddr> paddr = FindFreeBlock(size, align);
-    ASSERT(paddr);
-
-    for (u64 offset = 0; offset < size; offset += Memory::PAGE_SIZE) {
-        PageSlot(*paddr + offset) = static_cast<u64>(PageStatus::Allocated);
-    }
-
-    return *paddr;
-}
-
-PAddr MemoryManager::AllocateSpace(PAddr paddr, u64 size, u64 align) {
-    for (u64 offset = 0; offset < size; offset += Memory::PAGE_SIZE) {
-        if (IsPageMapped(paddr + offset)) {
-            return AllocateSpace(size, align);
-        }
-    }
-
-    for (u64 offset = 0; offset < size; offset += Memory::PAGE_SIZE) {
-        PageSlot(paddr + offset) = static_cast<u64>(PageStatus::Allocated);
-    }
-
-    return paddr;
-}
-
-PAddr MemoryManager::MapBufferEx(VAddr vaddr, u64 size) {
-    vaddr &= ~Memory::PAGE_MASK;
-
-    boost::optional<PAddr> paddr = FindFreeBlock(size);
-    ASSERT(paddr);
-
-    for (u64 offset = 0; offset < size; offset += Memory::PAGE_SIZE) {
-        PageSlot(*paddr + offset) = vaddr + offset;
-    }
-
-    return *paddr;
-}
-
-PAddr MemoryManager::MapBufferEx(VAddr vaddr, PAddr paddr, u64 size) {
-    vaddr &= ~Memory::PAGE_MASK;
-    paddr &= ~Memory::PAGE_MASK;
-
-    for (u64 offset = 0; offset < size; offset += Memory::PAGE_SIZE) {
-        if (PageSlot(paddr + offset) != static_cast<u64>(PageStatus::Allocated)) {
-            return MapBufferEx(vaddr, size);
-        }
-    }
-
-    for (u64 offset = 0; offset < size; offset += Memory::PAGE_SIZE) {
-        PageSlot(paddr + offset) = vaddr + offset;
-    }
-
-    return paddr;
-}
-
-boost::optional<PAddr> MemoryManager::FindFreeBlock(u64 size, u64 align) {
-    PAddr paddr{};
-    u64 free_space{};
-    align = (align + Memory::PAGE_MASK) & ~Memory::PAGE_MASK;
-
-    while (paddr + free_space < MAX_ADDRESS) {
-        if (!IsPageMapped(paddr + free_space)) {
-            free_space += Memory::PAGE_SIZE;
-            if (free_space >= size) {
-                return paddr;
-            }
-        } else {
-            paddr += free_space + Memory::PAGE_SIZE;
-            free_space = 0;
-            const u64 remainder{paddr % align};
-            if (!remainder) {
-                paddr = (paddr - remainder) + align;
-            }
-        }
-    }
-
-    return {};
-}
-
-VAddr MemoryManager::PhysicalToVirtualAddress(PAddr paddr) {
-    VAddr base_addr = PageSlot(paddr);
-    ASSERT(base_addr != static_cast<u64>(PageStatus::Unmapped));
-    return base_addr + (paddr & Memory::PAGE_MASK);
-}
-
-bool MemoryManager::IsPageMapped(PAddr paddr) {
-    return PageSlot(paddr) != static_cast<u64>(PageStatus::Unmapped);
-}
-
-VAddr& MemoryManager::PageSlot(PAddr paddr) {
-    auto& block = page_table[(paddr >> (Memory::PAGE_BITS + PAGE_TABLE_BITS)) & PAGE_TABLE_MASK];
-    if (!block) {
-        block = std::make_unique<PageBlock>();
-        for (unsigned index = 0; index < PAGE_BLOCK_SIZE; index++) {
-            (*block)[index] = static_cast<u64>(PageStatus::Unmapped);
-        }
-    }
-    return (*block)[(paddr >> Memory::PAGE_BITS) & PAGE_BLOCK_MASK];
-}
-
-} // namespace Nvidia
-} // namespace Service

src/core/hle/service/nvdrv/memory_manager.h

@@ -1,48 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <memory>
-#include "common/common_types.h"
-#include "core/memory.h"
-
-namespace Service {
-namespace Nvidia {
-
-class MemoryManager final {
-public:
-    MemoryManager() = default;
-
-    PAddr AllocateSpace(u64 size, u64 align);
-    PAddr AllocateSpace(PAddr paddr, u64 size, u64 align);
-    PAddr MapBufferEx(VAddr vaddr, u64 size);
-    PAddr MapBufferEx(VAddr vaddr, PAddr paddr, u64 size);
-    VAddr PhysicalToVirtualAddress(PAddr paddr);
-
-private:
-    boost::optional<PAddr> FindFreeBlock(u64 size, u64 align = 1);
-    bool IsPageMapped(PAddr paddr);
-    VAddr& PageSlot(PAddr paddr);
-
-    enum class PageStatus : u64 {
-        Unmapped = 0xFFFFFFFFFFFFFFFFULL,
-        Allocated = 0xFFFFFFFFFFFFFFFEULL,
-    };
-
-    static constexpr u64 MAX_ADDRESS{0x10000000000ULL};
-    static constexpr u64 PAGE_TABLE_BITS{14};
-    static constexpr u64 PAGE_TABLE_SIZE{1 << PAGE_TABLE_BITS};
-    static constexpr u64 PAGE_TABLE_MASK{PAGE_TABLE_SIZE - 1};
-    static constexpr u64 PAGE_BLOCK_BITS{14};
-    static constexpr u64 PAGE_BLOCK_SIZE{1 << PAGE_BLOCK_BITS};
-    static constexpr u64 PAGE_BLOCK_MASK{PAGE_BLOCK_SIZE - 1};
-
-    using PageBlock = std::array<VAddr, PAGE_BLOCK_SIZE>;
-    std::array<std::unique_ptr<PageBlock>, PAGE_TABLE_SIZE> page_table{};
-};
-
-} // namespace Nvidia
-} // namespace Service

src/core/hle/service/nvdrv/nvdrv.cpp

@@ -7,8 +7,6 @@
 #include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
 #include "core/hle/service/nvdrv/devices/nvhost_as_gpu.h"
 #include "core/hle/service/nvdrv/devices/nvhost_ctrl.h"
-#include "core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h"
-#include "core/hle/service/nvdrv/devices/nvhost_gpu.h"
 #include "core/hle/service/nvdrv/devices/nvmap.h"
 #include "core/hle/service/nvdrv/interface.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
@@ -23,20 +21,16 @@ void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto module_ = std::make_shared<Module>();
     std::make_shared<NVDRV>(module_, "nvdrv")->InstallAsService(service_manager);
     std::make_shared<NVDRV>(module_, "nvdrv:a")->InstallAsService(service_manager);
-    std::make_shared<NVDRV>(module_, "nvdrv:s")->InstallAsService(service_manager);
-    std::make_shared<NVDRV>(module_, "nvdrv:t")->InstallAsService(service_manager);
     std::make_shared<NVMEMP>()->InstallAsService(service_manager);
     nvdrv = module_;
 }
 
 Module::Module() {
     auto nvmap_dev = std::make_shared<Devices::nvmap>();
-    devices["/dev/nvhost-as-gpu"] = std::make_shared<Devices::nvhost_as_gpu>(nvmap_dev);
-    devices["/dev/nvhost-ctrl-gpu"] = std::make_shared<Devices::nvhost_ctrl_gpu>();
+    devices["/dev/nvhost-as-gpu"] = std::make_shared<Devices::nvhost_as_gpu>();
     devices["/dev/nvmap"] = nvmap_dev;
     devices["/dev/nvdisp_disp0"] = std::make_shared<Devices::nvdisp_disp0>(nvmap_dev);
     devices["/dev/nvhost-ctrl"] = std::make_shared<Devices::nvhost_ctrl>();
-    devices["/dev/nvhost-gpu"] = std::make_shared<Devices::nvhost_gpu>();
 }
 
 u32 Module::Open(std::string device_name) {
@@ -51,12 +45,12 @@ u32 Module::Open(std::string device_name) {
     return fd;
 }
 
-u32 Module::Ioctl(u32 fd, u32_le command, const std::vector<u8>& input, std::vector<u8>& output) {
+u32 Module::Ioctl(u32 fd, u32 command, const std::vector<u8>& input, std::vector<u8>& output) {
     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, output);
+    return device->ioctl(command, input, output);
 }
 
 ResultCode Module::Close(u32 fd) {

src/core/hle/service/nvflinger/buffer_queue.cpp

@@ -14,7 +14,6 @@ namespace NVFlinger {
 
 BufferQueue::BufferQueue(u32 id, u64 layer_id) : id(id), layer_id(layer_id) {
     native_handle = Kernel::Event::Create(Kernel::ResetType::OneShot, "BufferQueue NativeHandle");
-    native_handle->Signal();
 }
 
 void BufferQueue::SetPreallocatedBuffer(u32 slot, IGBPBuffer& igbp_buffer) {

src/core/hle/service/pctl/pctl_a.cpp

@@ -15,10 +15,10 @@ public:
 };
 
 void PCTL_A::GetService(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<IParentalControlService>();
-    LOG_DEBUG(Service_PCTL, "called");
+    LOG_DEBUG(Service, "called");
 }
 
 PCTL_A::PCTL_A() : ServiceFramework("pctl:a") {

src/core/hle/service/service.cpp

@@ -22,7 +22,6 @@
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/hid/hid.h"
 #include "core/hle/service/lm/lm.h"
-#include "core/hle/service/nifm/nifm.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/pctl/pctl.h"
 #include "core/hle/service/service.h"
@@ -133,7 +132,7 @@ void ServiceFrameworkBase::InvokeRequest(Kernel::HLERequestContext& ctx) {
 ResultCode ServiceFrameworkBase::HandleSyncRequest(Kernel::HLERequestContext& context) {
     switch (context.GetCommandType()) {
     case IPC::CommandType::Close: {
-        IPC::ResponseBuilder rb{context, 2};
+        IPC::RequestBuilder rb{context, 1};
         rb.Push(RESULT_SUCCESS);
         return ResultCode(ErrorModule::HIPC, ErrorDescription::RemoteProcessDead);
     }
@@ -181,7 +180,6 @@ void Init() {
     FileSystem::InstallInterfaces(*SM::g_service_manager);
     HID::InstallInterfaces(*SM::g_service_manager);
     LM::InstallInterfaces(*SM::g_service_manager);
-    NIFM::InstallInterfaces(*SM::g_service_manager);
     Nvidia::InstallInterfaces(*SM::g_service_manager);
     PCTL::InstallInterfaces(*SM::g_service_manager);
     Sockets::InstallInterfaces(*SM::g_service_manager);

src/core/hle/service/set/set.cpp

@@ -13,19 +13,18 @@ namespace Service {
 namespace Set {
 
 void SET::GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    u32 id = rp.Pop<u32>();
     constexpr std::array<u8, 13> lang_codes{};
 
     const auto& output_buffer = ctx.BufferDescriptorC()[0];
 
     Memory::WriteBlock(output_buffer.Address(), lang_codes.data(), lang_codes.size());
 
-    IPC::ResponseBuilder rb{ctx, 2};
+    IPC::RequestBuilder rb{ctx, 4};
 
     rb.Push(RESULT_SUCCESS);
+    rb.Push(static_cast<u64>(lang_codes.size()));
 
-    LOG_WARNING(Service_SET, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
 }
 
 SET::SET(const char* name) : ServiceFramework(name) {

src/core/hle/service/sm/controller.cpp

@@ -4,43 +4,42 @@
 
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/session.h"
+#include "core/hle/kernel/domain.h"
 #include "core/hle/service/sm/controller.h"
 
 namespace Service {
 namespace SM {
 
 void Controller::ConvertSessionToDomain(Kernel::HLERequestContext& ctx) {
-    ASSERT_MSG(!ctx.Session()->IsDomain(), "session is alread a domain");
-    ctx.Session()->ConvertToDomain();
+    auto domain = Kernel::Domain::CreateFromSession(*ctx.ServerSession()->parent).Unwrap();
 
-    IPC::ResponseBuilder rb{ctx, 3};
+    IPC::RequestBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(1); // Converted sessions start with 1 request handler
+    rb.Push(static_cast<u32>(domain->request_handlers.size()));
 
-    LOG_DEBUG(Service, "called, server_session=%d", ctx.Session()->GetObjectId());
+    LOG_DEBUG(Service, "called, domain=%d", domain->GetObjectId());
 }
 
 void Controller::DuplicateSession(Kernel::HLERequestContext& ctx) {
-    // TODO(bunnei): This is just creating a new handle to the same Session. I assume this is wrong
-    // and that we probably want to actually make an entirely new Session, but we still need to
-    // verify this on hardware.
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
+    IPC::RequestBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    Kernel::SharedPtr<Kernel::ClientSession> session{ctx.Session()->parent->client};
-    rb.PushMoveObjects(session);
+    // TODO(Subv): Check if this is correct
+    if (ctx.IsDomain())
+        rb.PushMoveObjects(ctx.Domain());
+    else
+        rb.PushMoveObjects(ctx.ServerSession());
 
-    LOG_DEBUG(Service, "called, session=%u", session->GetObjectId());
+    LOG_DEBUG(Service, "called");
 }
 
 void Controller::DuplicateSessionEx(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service, "(STUBBED) called, using DuplicateSession");
-
     DuplicateSession(ctx);
+
+    LOG_WARNING(Service, "(STUBBED) called, using DuplicateSession");
 }
 
 void Controller::QueryPointerBufferSize(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 3};
+    IPC::RequestBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
     rb.Push<u32>(0x500);
 

src/core/hle/service/sm/sm.cpp

@@ -83,7 +83,7 @@ std::shared_ptr<ServiceManager> g_service_manager;
  *      0: ResultCode
  */
 void SM::Initialize(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2};
+    IPC::RequestBuilder rb{ctx, 1};
     rb.Push(RESULT_SUCCESS);
     LOG_DEBUG(Service_SM, "called");
 }
@@ -99,12 +99,10 @@ void SM::GetService(Kernel::HLERequestContext& ctx) {
 
     auto client_port = service_manager->GetServicePort(name);
     if (client_port.Failed()) {
-        IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
+        IPC::RequestBuilder rb = rp.MakeBuilder(2, 0, 0, 0);
         rb.Push(client_port.Code());
         LOG_ERROR(Service_SM, "called service=%s -> error 0x%08X", name.c_str(),
                   client_port.Code().raw);
-        if (name.length() == 0)
-            return; // LibNX Fix
         UNIMPLEMENTED();
         return;
     }
@@ -114,8 +112,7 @@ void SM::GetService(Kernel::HLERequestContext& ctx) {
     if (session.Succeeded()) {
         LOG_DEBUG(Service_SM, "called service=%s -> session=%u", name.c_str(),
                   (*session)->GetObjectId());
-        IPC::ResponseBuilder rb =
-            rp.MakeBuilder(2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles);
+        IPC::RequestBuilder rb = rp.MakeBuilder(2, 0, 1, 0);
         rb.Push(session.Code());
         rb.PushMoveObjects(std::move(session).Unwrap());
     }

src/core/hle/service/sockets/bsd_u.cpp

@@ -11,7 +11,7 @@ namespace Sockets {
 void BSD_U::RegisterClient(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 3};
+    IPC::RequestBuilder rb{ctx, 3};
 
     rb.Push(RESULT_SUCCESS);
     rb.Push<u32>(0); // bsd errno
@@ -28,7 +28,7 @@ void BSD_U::Socket(Kernel::HLERequestContext& ctx) {
 
     u32 fd = next_fd++;
 
-    IPC::ResponseBuilder rb{ctx, 4};
+    IPC::RequestBuilder rb{ctx, 4};
 
     rb.Push(RESULT_SUCCESS);
     rb.Push<u32>(fd);
@@ -38,7 +38,7 @@ void BSD_U::Socket(Kernel::HLERequestContext& ctx) {
 void BSD_U::Connect(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 4};
+    IPC::RequestBuilder rb{ctx, 4};
 
     rb.Push(RESULT_SUCCESS);
     rb.Push<u32>(0); // ret
@@ -48,17 +48,7 @@ void BSD_U::Connect(Kernel::HLERequestContext& ctx) {
 void BSD_U::SendTo(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 4};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(0); // ret
-    rb.Push<u32>(0); // bsd errno
-}
-
-void BSD_U::Close(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 4};
+    IPC::RequestBuilder rb{ctx, 4};
 
     rb.Push(RESULT_SUCCESS);
     rb.Push<u32>(0); // ret
@@ -69,8 +59,7 @@ BSD_U::BSD_U() : ServiceFramework("bsd:u") {
     static const FunctionInfo functions[] = {{0, &BSD_U::RegisterClient, "RegisterClient"},
                                              {2, &BSD_U::Socket, "Socket"},
                                              {11, &BSD_U::SendTo, "SendTo"},
-                                             {14, &BSD_U::Connect, "Connect"},
-                                             {26, &BSD_U::Close, "Close"}};
+                                             {14, &BSD_U::Connect, "Connect"}};
     RegisterHandlers(functions);
 }
 

src/core/hle/service/sockets/bsd_u.h

@@ -20,7 +20,6 @@ private:
     void Socket(Kernel::HLERequestContext& ctx);
     void Connect(Kernel::HLERequestContext& ctx);
     void SendTo(Kernel::HLERequestContext& ctx);
-    void Close(Kernel::HLERequestContext& ctx);
 
     /// Id to use for the next open file descriptor.
     u32 next_fd = 1;

src/core/hle/service/sockets/sfdnsres.cpp

@@ -1,36 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/sockets/sfdnsres.h"
-
-namespace Service {
-namespace Sockets {
-
-void SFDNSRES::GetAddrInfo(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-
-    LOG_WARNING(Service, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 2};
-
-    rb.Push(RESULT_SUCCESS);
-}
-
-SFDNSRES::SFDNSRES() : ServiceFramework("sfdnsres") {
-    static const FunctionInfo functions[] = {{0, nullptr, "SetDnsAddressesPrivate"},
-                                             {1, nullptr, "GetDnsAddressPrivate"},
-                                             {2, nullptr, "GetHostByName"},
-                                             {3, nullptr, "GetHostByAddr"},
-                                             {4, nullptr, "GetHostStringError"},
-                                             {5, nullptr, "GetGaiStringError"},
-                                             {6, &SFDNSRES::GetAddrInfo, "GetAddrInfo"},
-                                             {7, nullptr, "GetNameInfo"},
-                                             {8, nullptr, "RequestCancelHandle"},
-                                             {9, nullptr, "CancelSocketCall"}};
-    RegisterHandlers(functions);
-}
-
-} // namespace Sockets
-} // namespace Service

src/core/hle/service/sockets/sfdnsres.h

@@ -12,11 +12,10 @@ namespace Sockets {
 
 class SFDNSRES final : public ServiceFramework<SFDNSRES> {
 public:
-    SFDNSRES();
+    SFDNSRES() : ServiceFramework("sfdnsres") {}
     ~SFDNSRES() = default;
 
 private:
-    void GetAddrInfo(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Sockets

src/core/hle/service/time/time.cpp

@@ -4,7 +4,6 @@
 
 #include <chrono>
 #include "common/logging/log.h"
-#include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
@@ -20,98 +19,63 @@ public:
     ISystemClock() : ServiceFramework("ISystemClock") {
         static const FunctionInfo functions[] = {
             {0, &ISystemClock::GetCurrentTime, "GetCurrentTime"},
-            {2, &ISystemClock::GetSystemClockContext, "GetSystemClockContext"}};
-        RegisterHandlers(functions);
-    }
-
-private:
-    void GetCurrentTime(Kernel::HLERequestContext& ctx) {
-        const s64 time_since_epoch{std::chrono::duration_cast<std::chrono::seconds>(
-                                       std::chrono::system_clock::now().time_since_epoch())
-                                       .count()};
-        LOG_DEBUG(Service_Time, "called");
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(time_since_epoch);
-    }
-
-    void GetSystemClockContext(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_Time, "(STUBBED) called");
-        SystemClockContext system_clock_ontext{};
-        IPC::ResponseBuilder rb{ctx, (sizeof(SystemClockContext) / 4) + 2};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushRaw(system_clock_ontext);
-    }
-};
-
-class ISteadyClock final : public ServiceFramework<ISteadyClock> {
-public:
-    ISteadyClock() : ServiceFramework("ISteadyClock") {
-        static const FunctionInfo functions[] = {
-            {0, &ISteadyClock::GetCurrentTimePoint, "GetCurrentTimePoint"},
         };
         RegisterHandlers(functions);
     }
 
 private:
-    void GetCurrentTimePoint(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Time, "called");
-        SteadyClockTimePoint steady_clock_time_point{cyclesToMs(CoreTiming::GetTicks()) / 1000};
-        IPC::ResponseBuilder rb{ctx, (sizeof(SteadyClockTimePoint) / 4) + 2};
+    void GetCurrentTime(Kernel::HLERequestContext& ctx) {
+        const s64 time_since_epoch{std::chrono::duration_cast<std::chrono::milliseconds>(
+                                       std::chrono::system_clock::now().time_since_epoch())
+                                       .count()};
+        IPC::RequestBuilder rb{ctx, 4};
         rb.Push(RESULT_SUCCESS);
-        rb.PushRaw(steady_clock_time_point);
+        rb.Push<u64>(time_since_epoch);
+        LOG_DEBUG(Service, "called");
     }
 };
 
+class ISteadyClock final : public ServiceFramework<ISteadyClock> {
+public:
+    ISteadyClock() : ServiceFramework("ISteadyClock") {}
+};
+
 class ITimeZoneService final : public ServiceFramework<ITimeZoneService> {
 public:
     ITimeZoneService() : ServiceFramework("ITimeZoneService") {
         static const FunctionInfo functions[] = {
             {0, &ITimeZoneService::GetDeviceLocationName, "GetDeviceLocationName"},
-            {1, nullptr, "SetDeviceLocationName"},
             {2, &ITimeZoneService::GetTotalLocationNameCount, "GetTotalLocationNameCount"},
-            {3, nullptr, "LoadLocationNameList"},
-            {4, &ITimeZoneService::LoadTimeZoneRule, "LoadTimeZoneRule"},
-            {5, nullptr, "GetTimeZoneRuleVersion"},
-            {100, nullptr, "ToCalendarTime"},
             {101, &ITimeZoneService::ToCalendarTimeWithMyRule, "ToCalendarTimeWithMyRule"},
-            {200, nullptr, "ToPosixTime"},
-            {201, nullptr, "ToPosixTimeWithMyRule"},
         };
         RegisterHandlers(functions);
     }
 
 private:
     void GetDeviceLocationName(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_Time, "(STUBBED) called");
+        LOG_WARNING(Service, "(STUBBED) called");
         LocationName location_name{};
-        IPC::ResponseBuilder rb{ctx, (sizeof(LocationName) / 4) + 2};
+        IPC::RequestBuilder rb{ctx, (sizeof(LocationName) / 4) + 2};
         rb.Push(RESULT_SUCCESS);
         rb.PushRaw(location_name);
     }
 
     void GetTotalLocationNameCount(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_Time, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 3};
+        LOG_WARNING(Service, "(STUBBED) called");
+        IPC::RequestBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(0);
     }
 
-    void LoadTimeZoneRule(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_Time, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
     void ToCalendarTimeWithMyRule(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         u64 posix_time = rp.Pop<u64>();
 
-        LOG_WARNING(Service_Time, "(STUBBED) called, posix_time=0x%016llX", posix_time);
+        LOG_WARNING(Service, "(STUBBED) called, posix_time=0x%016llX", posix_time);
 
         CalendarTime calendar_time{2018, 1, 1, 0, 0, 0};
         CalendarAdditionalInfo additional_info{};
-        IPC::ResponseBuilder rb{ctx, 10};
+        IPC::RequestBuilder rb{ctx, 10};
         rb.Push(RESULT_SUCCESS);
         rb.PushRaw(calendar_time);
         rb.PushRaw(additional_info);
@@ -119,31 +83,52 @@ private:
 };
 
 void Module::Interface::GetStandardUserSystemClock(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    // TODO(Subv): Verify if this should return the interface as a domain object when called from
+    // within a domain.
+    auto system_clock = std::make_shared<ISystemClock>();
+    auto sessions = Kernel::ServerSession::CreateSessionPair(system_clock->GetServiceName());
+    auto server = std::get<Kernel::SharedPtr<Kernel::ServerSession>>(sessions);
+    auto client = std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions);
+    system_clock->ClientConnected(server);
+    LOG_DEBUG(Service, "called, initialized ISystemClock -> session=%u", client->GetObjectId());
+    IPC::RequestBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISystemClock>();
-    LOG_DEBUG(Service_Time, "called");
+    rb.PushMoveObjects(std::move(client));
 }
 
 void Module::Interface::GetStandardNetworkSystemClock(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    // TODO(Subv): Verify if this should return the interface as a domain object when called from
+    // within a domain.
+    auto system_clock = std::make_shared<ISystemClock>();
+    auto sessions = Kernel::ServerSession::CreateSessionPair(system_clock->GetServiceName());
+    auto server = std::get<Kernel::SharedPtr<Kernel::ServerSession>>(sessions);
+    auto client = std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions);
+    system_clock->ClientConnected(server);
+    LOG_DEBUG(Service, "called, initialized ISystemClock -> session=%u", client->GetObjectId());
+    IPC::RequestBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISystemClock>();
-    LOG_DEBUG(Service_Time, "called");
+    rb.PushMoveObjects(std::move(client));
 }
 
 void Module::Interface::GetStandardSteadyClock(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    // TODO(Subv): Verify if this should return the interface as a domain object when called from
+    // within a domain.
+    auto steady_clock = std::make_shared<ISteadyClock>();
+    auto sessions = Kernel::ServerSession::CreateSessionPair(steady_clock->GetServiceName());
+    auto server = std::get<Kernel::SharedPtr<Kernel::ServerSession>>(sessions);
+    auto client = std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions);
+    steady_clock->ClientConnected(server);
+    LOG_DEBUG(Service, "called, initialized ISteadyClock -> session=%u", client->GetObjectId());
+    IPC::RequestBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISteadyClock>();
-    LOG_DEBUG(Service_Time, "called");
+    rb.PushMoveObjects(std::move(client));
 }
 
 void Module::Interface::GetTimeZoneService(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<ITimeZoneService>();
-    LOG_DEBUG(Service_Time, "called");
+    LOG_DEBUG(Service, "called");
 }
 
 Module::Interface::Interface(std::shared_ptr<Module> time, const char* name)

src/core/hle/service/time/time.h

@@ -33,19 +33,6 @@ struct CalendarAdditionalInfo {
 static_assert(sizeof(CalendarAdditionalInfo) == 0x18,
               "CalendarAdditionalInfo structure has incorrect size");
 
-// TODO(bunnei) RE this structure
-struct SystemClockContext {
-    INSERT_PADDING_BYTES(0x20);
-};
-static_assert(sizeof(SystemClockContext) == 0x20,
-              "SystemClockContext structure has incorrect size");
-
-struct SteadyClockTimePoint {
-    u64 value;
-    INSERT_PADDING_WORDS(4);
-};
-static_assert(sizeof(SteadyClockTimePoint) == 0x18, "SteadyClockTimePoint is incorrect size");
-
 class Module final {
 public:
     class Interface : public ServiceFramework<Interface> {

src/core/hle/service/vi/vi.cpp

@@ -11,23 +11,12 @@
 #include "core/hle/service/nvflinger/buffer_queue.h"
 #include "core/hle/service/vi/vi.h"
 #include "core/hle/service/vi/vi_m.h"
-#include "core/hle/service/vi/vi_s.h"
-#include "core/hle/service/vi/vi_u.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
 
 namespace Service {
 namespace VI {
 
-struct DisplayInfo {
-    char display_name[0x40]{"Default"};
-    u64 unknown_1{1};
-    u64 unknown_2{1};
-    u64 width{1920};
-    u64 height{1080};
-};
-static_assert(sizeof(DisplayInfo) == 0x60, "DisplayInfo has wrong size");
-
 class Parcel {
 public:
     // This default size was chosen arbitrarily.
@@ -438,7 +427,7 @@ private:
         auto& output_buffer = ctx.BufferDescriptorB()[0];
 
         auto buffer_queue = nv_flinger->GetBufferQueue(id);
-        LOG_WARNING(Service_VI, "(STUBBED) called, transaction=%x", transaction);
+
         if (transaction == TransactionId::Connect) {
             IGBPConnectRequestParcel request{input_data};
             IGBPConnectResponseParcel response{1280, 720};
@@ -496,7 +485,8 @@ private:
             ASSERT_MSG(false, "Unimplemented");
         }
 
-        IPC::ResponseBuilder rb{ctx, 2};
+        LOG_WARNING(Service, "(STUBBED) called");
+        IPC::RequestBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
     }
 
@@ -506,8 +496,8 @@ private:
         s32 addval = rp.PopRaw<s32>();
         u32 type = rp.Pop<u32>();
 
-        LOG_WARNING(Service_VI, "(STUBBED) called id=%u, addval=%08X, type=%08X", id, addval, type);
-        IPC::ResponseBuilder rb{ctx, 2};
+        LOG_WARNING(Service, "(STUBBED) called id=%u, addval=%08X, type=%08X", id, addval, type);
+        IPC::RequestBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
     }
 
@@ -520,8 +510,8 @@ private:
 
         // TODO(Subv): Find out what this actually is.
 
-        LOG_WARNING(Service_VI, "(STUBBED) called id=%u, unknown=%08X", id, unknown);
-        IPC::ResponseBuilder rb{ctx, 2, 1};
+        LOG_WARNING(Service, "(STUBBED) called id=%u, unknown=%08X", id, unknown);
+        IPC::RequestBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
         rb.PushCopyObjects(buffer_queue->GetNativeHandle());
     }
@@ -542,12 +532,12 @@ public:
 
 private:
     void SetLayerZ(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service, "(STUBBED) called");
         IPC::RequestParser rp{ctx};
         u64 layer_id = rp.Pop<u64>();
         u64 z_value = rp.Pop<u64>();
 
-        IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
+        IPC::RequestBuilder rb = rp.MakeBuilder(2, 0, 0, 0);
         rb.Push(RESULT_SUCCESS);
     }
 };
@@ -568,16 +558,16 @@ public:
 
 private:
     void CloseDisplay(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service, "(STUBBED) called");
         IPC::RequestParser rp{ctx};
         u64 display = rp.Pop<u64>();
 
-        IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
+        IPC::RequestBuilder rb = rp.MakeBuilder(2, 0, 0, 0);
         rb.Push(RESULT_SUCCESS);
     }
 
     void CreateManagedLayer(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service, "(STUBBED) called");
         IPC::RequestParser rp{ctx};
         u32 unknown = rp.Pop<u32>();
         rp.Skip(1, false);
@@ -586,18 +576,18 @@ private:
 
         u64 layer_id = nv_flinger->CreateLayer(display);
 
-        IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
+        IPC::RequestBuilder rb = rp.MakeBuilder(4, 0, 0, 0);
         rb.Push(RESULT_SUCCESS);
         rb.Push(layer_id);
     }
 
     void AddToLayerStack(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
+        LOG_WARNING(Service, "(STUBBED) called");
         IPC::RequestParser rp{ctx};
         u32 stack = rp.Pop<u32>();
         u64 layer_id = rp.Pop<u64>();
 
-        IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
+        IPC::RequestBuilder rb = rp.MakeBuilder(2, 0, 0, 0);
         rb.Push(RESULT_SUCCESS);
     }
 
@@ -605,40 +595,40 @@ private:
 };
 
 void IApplicationDisplayService::GetRelayService(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<IHOSBinderDriver>(nv_flinger);
 }
 
 void IApplicationDisplayService::GetSystemDisplayService(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<ISystemDisplayService>();
 }
 
 void IApplicationDisplayService::GetManagerDisplayService(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<IManagerDisplayService>(nv_flinger);
 }
 
 void IApplicationDisplayService::GetIndirectDisplayTransactionService(
     Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<IHOSBinderDriver>(nv_flinger);
 }
 
 void IApplicationDisplayService::OpenDisplay(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
     IPC::RequestParser rp{ctx};
     auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
     auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
@@ -647,22 +637,22 @@ void IApplicationDisplayService::OpenDisplay(Kernel::HLERequestContext& ctx) {
 
     ASSERT_MSG(name == "Default", "Non-default displays aren't supported yet");
 
-    IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
+    IPC::RequestBuilder rb = rp.MakeBuilder(4, 0, 0, 0);
     rb.Push(RESULT_SUCCESS);
     rb.Push<u64>(nv_flinger->OpenDisplay(name));
 }
 
 void IApplicationDisplayService::CloseDisplay(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
     IPC::RequestParser rp{ctx};
     u64 display_id = rp.Pop<u64>();
 
-    IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
+    IPC::RequestBuilder rb = rp.MakeBuilder(4, 0, 0, 0);
     rb.Push(RESULT_SUCCESS);
 }
 
 void IApplicationDisplayService::OpenLayer(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
     IPC::RequestParser rp{ctx};
     auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
     auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
@@ -681,7 +671,7 @@ void IApplicationDisplayService::OpenLayer(Kernel::HLERequestContext& ctx) {
     auto data = native_window.Serialize();
     Memory::WriteBlock(buffer.Address(), data.data(), data.size());
 
-    IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
+    IPC::RequestBuilder rb = rp.MakeBuilder(4, 0, 0, 0);
     rb.Push(RESULT_SUCCESS);
     rb.Push<u64>(data.size());
 }
@@ -691,7 +681,6 @@ void IApplicationDisplayService::CreateStrayLayer(Kernel::HLERequestContext& ctx
 
     IPC::RequestParser rp{ctx};
     u32 flags = rp.Pop<u32>();
-    rp.Pop<u32>(); // padding
     u64 display_id = rp.Pop<u64>();
 
     auto& buffer = ctx.BufferDescriptorB()[0];
@@ -705,51 +694,40 @@ void IApplicationDisplayService::CreateStrayLayer(Kernel::HLERequestContext& ctx
     auto data = native_window.Serialize();
     Memory::WriteBlock(buffer.Address(), data.data(), data.size());
 
-    IPC::ResponseBuilder rb = rp.MakeBuilder(6, 0, 0);
+    IPC::RequestBuilder rb = rp.MakeBuilder(6, 0, 0, 0);
     rb.Push(RESULT_SUCCESS);
     rb.Push(layer_id);
     rb.Push<u64>(data.size());
 }
 
 void IApplicationDisplayService::DestroyStrayLayer(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
 
     IPC::RequestParser rp{ctx};
     u64 layer_id = rp.Pop<u64>();
 
-    IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
+    IPC::RequestBuilder rb = rp.MakeBuilder(2, 0, 0, 0);
     rb.Push(RESULT_SUCCESS);
 }
 
 void IApplicationDisplayService::SetLayerScalingMode(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
     IPC::RequestParser rp{ctx};
     u32 scaling_mode = rp.Pop<u32>();
     u64 unknown = rp.Pop<u64>();
 
-    IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
+    IPC::RequestBuilder rb = rp.MakeBuilder(2, 0, 0, 0);
     rb.Push(RESULT_SUCCESS);
 }
 
-void IApplicationDisplayService::ListDisplays(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    DisplayInfo display_info;
-    auto& buffer = ctx.BufferDescriptorB()[0];
-    Memory::WriteBlock(buffer.Address(), &display_info, sizeof(DisplayInfo));
-    IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(1);
-    LOG_WARNING(Service_VI, "(STUBBED) called");
-}
-
 void IApplicationDisplayService::GetDisplayVsyncEvent(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
     IPC::RequestParser rp{ctx};
     u64 display_id = rp.Pop<u64>();
 
     auto vsync_event = nv_flinger->GetVsyncEvent(display_id);
 
-    IPC::ResponseBuilder rb = rp.MakeBuilder(2, 1, 0);
+    IPC::RequestBuilder rb = rp.MakeBuilder(2, 1, 0, 0);
     rb.Push(RESULT_SUCCESS);
     rb.PushCopyObjects(vsync_event);
 }
@@ -763,7 +741,7 @@ IApplicationDisplayService::IApplicationDisplayService(
         {102, &IApplicationDisplayService::GetManagerDisplayService, "GetManagerDisplayService"},
         {103, &IApplicationDisplayService::GetIndirectDisplayTransactionService,
          "GetIndirectDisplayTransactionService"},
-        {1000, &IApplicationDisplayService::ListDisplays, "ListDisplays"},
+        {1000, nullptr, "ListDisplays"},
         {1010, &IApplicationDisplayService::OpenDisplay, "OpenDisplay"},
         {1020, &IApplicationDisplayService::CloseDisplay, "CloseDisplay"},
         {2101, &IApplicationDisplayService::SetLayerScalingMode, "SetLayerScalingMode"},
@@ -778,8 +756,6 @@ IApplicationDisplayService::IApplicationDisplayService(
 void InstallInterfaces(SM::ServiceManager& service_manager,
                        std::shared_ptr<NVFlinger::NVFlinger> nv_flinger) {
     std::make_shared<VI_M>(nv_flinger)->InstallAsService(service_manager);
-    std::make_shared<VI_S>(nv_flinger)->InstallAsService(service_manager);
-    std::make_shared<VI_U>(nv_flinger)->InstallAsService(service_manager);
 }
 
 } // namespace VI

src/core/hle/service/vi/vi.h

@@ -30,7 +30,6 @@ private:
     void OpenDisplay(Kernel::HLERequestContext& ctx);
     void CloseDisplay(Kernel::HLERequestContext& ctx);
     void SetLayerScalingMode(Kernel::HLERequestContext& ctx);
-    void ListDisplays(Kernel::HLERequestContext& ctx);
     void OpenLayer(Kernel::HLERequestContext& ctx);
     void CreateStrayLayer(Kernel::HLERequestContext& ctx);
     void DestroyStrayLayer(Kernel::HLERequestContext& ctx);

src/core/hle/service/vi/vi_m.cpp

@@ -11,10 +11,9 @@ namespace Service {
 namespace VI {
 
 void VI_M::GetDisplayService(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
+    IPC::RequestBuilder rb{ctx, 2, 0, 0, 1};
     rb.PushIpcInterface<IApplicationDisplayService>(nv_flinger);
 }
 

src/core/hle/service/vi/vi_s.cpp

@@ -1,31 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/vi/vi.h"
-#include "core/hle/service/vi/vi_s.h"
-
-namespace Service {
-namespace VI {
-
-void VI_S::GetDisplayService(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IApplicationDisplayService>(nv_flinger);
-}
-
-VI_S::VI_S(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
-    : ServiceFramework("vi:s"), nv_flinger(std::move(nv_flinger)) {
-    static const FunctionInfo functions[] = {
-        {1, &VI_S::GetDisplayService, "GetDisplayService"},
-        {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace VI
-} // namespace Service

src/core/hle/service/vi/vi_s.h

@@ -1,29 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace NVFlinger {
-class NVFlinger;
-}
-
-namespace VI {
-
-class VI_S final : public ServiceFramework<VI_S> {
-public:
-    VI_S(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
-    ~VI_S() = default;
-
-private:
-    void GetDisplayService(Kernel::HLERequestContext& ctx);
-
-    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
-};
-
-} // namespace VI
-} // namespace Service

src/core/hle/service/vi/vi_u.cpp

@@ -1,31 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/vi/vi.h"
-#include "core/hle/service/vi/vi_u.h"
-
-namespace Service {
-namespace VI {
-
-void VI_U::GetDisplayService(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_VI, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IApplicationDisplayService>(nv_flinger);
-}
-
-VI_U::VI_U(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
-    : ServiceFramework("vi:u"), nv_flinger(std::move(nv_flinger)) {
-    static const FunctionInfo functions[] = {
-        {0, &VI_U::GetDisplayService, "GetDisplayService"},
-        {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace VI
-} // namespace Service

src/core/hle/service/vi/vi_u.h

@@ -1,29 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include "core/hle/service/service.h"
-
-namespace Service {
-namespace NVFlinger {
-class NVFlinger;
-}
-
-namespace VI {
-
-class VI_U final : public ServiceFramework<VI_U> {
-public:
-    VI_U(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
-    ~VI_U() = default;
-
-private:
-    void GetDisplayService(Kernel::HLERequestContext& ctx);
-
-    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
-};
-
-} // namespace VI
-} // namespace Service

src/core/loader/deconstructed_rom_directory.cpp

@@ -29,7 +29,7 @@ static std::string FindRomFS(const std::string& directory) {
 
         // Verify extension
         const std::string extension = physical_name.substr(physical_name.find_last_of(".") + 1);
-        if (Common::ToLower(extension) != "romfs") {
+        if (Common::ToLower(extension) != "istorage") {
             return true;
         }
 
@@ -38,7 +38,7 @@ static std::string FindRomFS(const std::string& directory) {
         return false;
     };
 
-    // Search the specified directory recursively, looking for the first .romfs file, which will
+    // Search the specified directory recursively, looking for the first .istorage file, which will
     // be used for the RomFS
     FileUtil::ForeachDirectoryEntry(nullptr, directory, callback);
 
@@ -128,10 +128,10 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
         Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
     process->Run(Memory::PROCESS_IMAGE_VADDR, 48, Kernel::DEFAULT_STACK_SIZE);
 
-    // Find the RomFS by searching for a ".romfs" file in this directory
+    // Find the RomFS by searching for a ".istorage" file in this directory
     filepath_romfs = FindRomFS(directory);
 
-    // Register the RomFS if a ".romfs" file was found
+    // Register the RomFS if a ".istorage" file was found
     if (!filepath_romfs.empty()) {
         Service::FileSystem::RegisterFileSystem(std::make_unique<FileSys::RomFS_Factory>(*this),
                                                 Service::FileSystem::Type::RomFS);

src/core/loader/deconstructed_rom_directory.h

@@ -15,7 +15,7 @@ namespace Loader {
  * This class loads a "deconstructed ROM directory", which are the typical format we see for Switch
  * game dumps. The path should be a "main" NSO, which must be in a directory that contains the other
  * standard ExeFS NSOs (e.g. rtld, sdk, etc.). It will automatically find and load these.
- * Furthermore, it will look for the first .romfs file (optionally) and use this for the RomFS.
+ * Furthermore, it will look for the first .istorage file (optionally) and use this for the RomFS.
  */
 class AppLoader_DeconstructedRomDirectory final : public AppLoader {
 public:

src/core/memory.cpp

@@ -2,10 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
 #include <array>
 #include <cstring>
-#include <boost/optional.hpp>
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
@@ -14,6 +12,7 @@
 #include "core/core.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/process.h"
+#include "core/hle/lock.h"
 #include "core/memory.h"
 #include "core/memory_setup.h"
 #include "video_core/renderer_base.h"
@@ -41,12 +40,16 @@ static void MapPages(PageTable& page_table, VAddr base, u64 size, u8* memory, Pa
     LOG_DEBUG(HW_Memory, "Mapping %p onto %08X-%08X", memory, base * PAGE_SIZE,
               (base + size) * PAGE_SIZE);
 
+    RasterizerFlushVirtualRegion(base << PAGE_BITS, size * PAGE_SIZE,
+                                 FlushMode::FlushAndInvalidate);
+
     VAddr end = base + size;
     while (base != end) {
         ASSERT_MSG(base < PAGE_TABLE_NUM_ENTRIES, "out of range mapping at %08X", base);
 
         page_table.attributes[base] = type;
         page_table.pointers[base] = memory;
+        page_table.cached_res_count[base] = 0;
 
         base += 1;
         if (memory != nullptr)
@@ -60,110 +63,157 @@ void MapMemoryRegion(PageTable& page_table, VAddr base, u64 size, u8* target) {
     MapPages(page_table, base / PAGE_SIZE, size / PAGE_SIZE, target, PageType::Memory);
 }
 
-void MapIoRegion(PageTable& page_table, VAddr base, u64 size, MemoryHookPointer mmio_handler) {
+void MapIoRegion(PageTable& page_table, VAddr base, u64 size, MMIORegionPointer mmio_handler) {
     ASSERT_MSG((size & PAGE_MASK) == 0, "non-page aligned size: %08X", size);
     ASSERT_MSG((base & PAGE_MASK) == 0, "non-page aligned base: %08X", base);
     MapPages(page_table, base / PAGE_SIZE, size / PAGE_SIZE, nullptr, PageType::Special);
 
-    auto interval = boost::icl::discrete_interval<VAddr>::closed(base, base + size - 1);
-    SpecialRegion region{SpecialRegion::Type::IODevice, mmio_handler};
-    page_table.special_regions.add(std::make_pair(interval, std::set<SpecialRegion>{region}));
+    page_table.special_regions.emplace_back(SpecialRegion{base, size, mmio_handler});
 }
 
 void UnmapRegion(PageTable& page_table, VAddr base, u64 size) {
     ASSERT_MSG((size & PAGE_MASK) == 0, "non-page aligned size: %08X", size);
     ASSERT_MSG((base & PAGE_MASK) == 0, "non-page aligned base: %08X", base);
     MapPages(page_table, base / PAGE_SIZE, size / PAGE_SIZE, nullptr, PageType::Unmapped);
-
-    auto interval = boost::icl::discrete_interval<VAddr>::closed(base, base + size - 1);
-    page_table.special_regions.erase(interval);
 }
 
-void AddDebugHook(PageTable& page_table, VAddr base, u64 size, MemoryHookPointer hook) {
-    auto interval = boost::icl::discrete_interval<VAddr>::closed(base, base + size - 1);
-    SpecialRegion region{SpecialRegion::Type::DebugHook, hook};
-    page_table.special_regions.add(std::make_pair(interval, std::set<SpecialRegion>{region}));
+/**
+ * Gets a pointer to the exact memory at the virtual address (i.e. not page aligned)
+ * using a VMA from the current process
+ */
+static u8* GetPointerFromVMA(const Kernel::Process& process, VAddr vaddr) {
+    u8* direct_pointer = nullptr;
+
+    auto& vm_manager = process.vm_manager;
+
+    auto it = vm_manager.FindVMA(vaddr);
+    ASSERT(it != vm_manager.vma_map.end());
+
+    auto& vma = it->second;
+    switch (vma.type) {
+    case Kernel::VMAType::AllocatedMemoryBlock:
+        direct_pointer = vma.backing_block->data() + vma.offset;
+        break;
+    case Kernel::VMAType::BackingMemory:
+        direct_pointer = vma.backing_memory;
+        break;
+    case Kernel::VMAType::Free:
+        return nullptr;
+    default:
+        UNREACHABLE();
+    }
+
+    return direct_pointer + (vaddr - vma.base);
 }
 
-void RemoveDebugHook(PageTable& page_table, VAddr base, u64 size, MemoryHookPointer hook) {
-    auto interval = boost::icl::discrete_interval<VAddr>::closed(base, base + size - 1);
-    SpecialRegion region{SpecialRegion::Type::DebugHook, hook};
-    page_table.special_regions.subtract(std::make_pair(interval, std::set<SpecialRegion>{region}));
+/**
+ * Gets a pointer to the exact memory at the virtual address (i.e. not page aligned)
+ * using a VMA from the current process.
+ */
+static u8* GetPointerFromVMA(VAddr vaddr) {
+    return GetPointerFromVMA(*Kernel::g_current_process, vaddr);
 }
 
 /**
  * This function should only be called for virtual addreses with attribute `PageType::Special`.
  */
-static std::set<MemoryHookPointer> GetSpecialHandlers(const PageTable& page_table, VAddr vaddr,
-                                                      u64 size) {
-    std::set<MemoryHookPointer> result;
-    auto interval = boost::icl::discrete_interval<VAddr>::closed(vaddr, vaddr + size - 1);
-    auto interval_list = page_table.special_regions.equal_range(interval);
-    for (auto it = interval_list.first; it != interval_list.second; ++it) {
-        for (const auto& region : it->second) {
-            result.insert(region.handler);
+static MMIORegionPointer GetMMIOHandler(const PageTable& page_table, VAddr vaddr) {
+    for (const auto& region : page_table.special_regions) {
+        if (vaddr >= region.base && vaddr < (region.base + region.size)) {
+            return region.handler;
         }
     }
-    return result;
+    ASSERT_MSG(false, "Mapped IO page without a handler @ %08X", vaddr);
+    return nullptr; // Should never happen
 }
 
-static std::set<MemoryHookPointer> GetSpecialHandlers(VAddr vaddr, u64 size) {
+static MMIORegionPointer GetMMIOHandler(VAddr vaddr) {
     const PageTable& page_table = Kernel::g_current_process->vm_manager.page_table;
-    return GetSpecialHandlers(page_table, vaddr, size);
+    return GetMMIOHandler(page_table, vaddr);
 }
 
 template <typename T>
-boost::optional<T> ReadSpecial(VAddr addr);
+T ReadMMIO(MMIORegionPointer mmio_handler, VAddr addr);
 
 template <typename T>
 T Read(const VAddr vaddr) {
-    const PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
-    switch (type) {
-    case PageType::Unmapped:
-        LOG_ERROR(HW_Memory, "unmapped Read%lu @ 0x%016llX", sizeof(T) * 8, vaddr);
-        return 0;
-    case PageType::Special: {
-        if (auto result = ReadSpecial<T>(vaddr))
-            return *result;
-        [[fallthrough]];
-    }
-    case PageType::Memory: {
-        const u8* page_pointer = current_page_table->pointers[vaddr >> PAGE_BITS];
-        ASSERT_MSG(page_pointer, "Mapped memory page without a pointer @ %08X", vaddr);
-
+    const u8* page_pointer = current_page_table->pointers[vaddr >> PAGE_BITS];
+    if (page_pointer) {
+        // NOTE: Avoid adding any extra logic to this fast-path block
         T value;
         std::memcpy(&value, &page_pointer[vaddr & PAGE_MASK], sizeof(T));
         return value;
     }
+
+    // The memory access might do an MMIO or cached access, so we have to lock the HLE kernel state
+    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
+
+    PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
+    switch (type) {
+    case PageType::Unmapped:
+        LOG_ERROR(HW_Memory, "unmapped Read%lu @ 0x%llx", sizeof(T) * 8, vaddr);
+        return 0;
+    case PageType::Memory:
+        ASSERT_MSG(false, "Mapped memory page without a pointer @ %08X", vaddr);
+        break;
+    case PageType::RasterizerCachedMemory: {
+        RasterizerFlushVirtualRegion(vaddr, sizeof(T), FlushMode::Flush);
+
+        T value;
+        std::memcpy(&value, GetPointerFromVMA(vaddr), sizeof(T));
+        return value;
+    }
+    case PageType::Special:
+        return ReadMMIO<T>(GetMMIOHandler(vaddr), vaddr);
+    case PageType::RasterizerCachedSpecial: {
+        RasterizerFlushVirtualRegion(vaddr, sizeof(T), FlushMode::Flush);
+        return ReadMMIO<T>(GetMMIOHandler(vaddr), vaddr);
+    }
+    default:
+        UNREACHABLE();
     }
-    UNREACHABLE();
-    return 0;
 }
 
 template <typename T>
-bool WriteSpecial(VAddr addr, const T data);
+void WriteMMIO(MMIORegionPointer mmio_handler, VAddr addr, const T data);
 
 template <typename T>
 void Write(const VAddr vaddr, const T data) {
-    const PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
+    u8* page_pointer = current_page_table->pointers[vaddr >> PAGE_BITS];
+    if (page_pointer) {
+        // NOTE: Avoid adding any extra logic to this fast-path block
+        std::memcpy(&page_pointer[vaddr & PAGE_MASK], &data, sizeof(T));
+        return;
+    }
+
+    // The memory access might do an MMIO or cached access, so we have to lock the HLE kernel state
+    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
+
+    PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
     switch (type) {
     case PageType::Unmapped:
         LOG_ERROR(HW_Memory, "unmapped Write%lu 0x%08X @ 0x%08X", sizeof(data) * 8, (u32)data,
                   vaddr);
         return;
-    case PageType::Special: {
-        if (WriteSpecial<T>(vaddr, data))
-            return;
-        [[fallthrough]];
+    case PageType::Memory:
+        ASSERT_MSG(false, "Mapped memory page without a pointer @ %08X", vaddr);
+        break;
+    case PageType::RasterizerCachedMemory: {
+        RasterizerFlushVirtualRegion(vaddr, sizeof(T), FlushMode::FlushAndInvalidate);
+        std::memcpy(GetPointerFromVMA(vaddr), &data, sizeof(T));
+        break;
     }
-    case PageType::Memory: {
-        u8* page_pointer = current_page_table->pointers[vaddr >> PAGE_BITS];
-        ASSERT_MSG(page_pointer, "Mapped memory page without a pointer @ %08X", vaddr);
-        std::memcpy(&page_pointer[vaddr & PAGE_MASK], &data, sizeof(T));
-        return;
+    case PageType::Special:
+        WriteMMIO<T>(GetMMIOHandler(vaddr), vaddr, data);
+        break;
+    case PageType::RasterizerCachedSpecial: {
+        RasterizerFlushVirtualRegion(vaddr, sizeof(T), FlushMode::FlushAndInvalidate);
+        WriteMMIO<T>(GetMMIOHandler(vaddr), vaddr, data);
+        break;
     }
+    default:
+        UNREACHABLE();
     }
-    UNREACHABLE();
 }
 
 bool IsValidVirtualAddress(const Kernel::Process& process, const VAddr vaddr) {
@@ -172,20 +222,21 @@ bool IsValidVirtualAddress(const Kernel::Process& process, const VAddr vaddr) {
     if ((vaddr >> PAGE_BITS) >= PAGE_TABLE_NUM_ENTRIES)
         return false;
 
-    const PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
-    switch (type) {
-    case PageType::Unmapped:
-        return false;
-    case PageType::Memory:
+    const u8* page_pointer = page_table.pointers[vaddr >> PAGE_BITS];
+    if (page_pointer)
         return true;
-    case PageType::Special: {
-        for (auto handler : GetSpecialHandlers(page_table, vaddr, 1))
-            if (auto result = handler->IsValidAddress(vaddr))
-                return *result;
-        return current_page_table->pointers[vaddr >> PAGE_BITS] != nullptr;
+
+    if (page_table.attributes[vaddr >> PAGE_BITS] == PageType::RasterizerCachedMemory)
+        return true;
+
+    if (page_table.attributes[vaddr >> PAGE_BITS] != PageType::Special)
+        return false;
+
+    MMIORegionPointer mmio_region = GetMMIOHandler(page_table, vaddr);
+    if (mmio_region) {
+        return mmio_region->IsValidAddress(vaddr);
     }
-    }
-    UNREACHABLE();
+
     return false;
 }
 
@@ -203,6 +254,10 @@ u8* GetPointer(const VAddr vaddr) {
         return page_pointer + (vaddr & PAGE_MASK);
     }
 
+    if (current_page_table->attributes[vaddr >> PAGE_BITS] == PageType::RasterizerCachedMemory) {
+        return GetPointerFromVMA(vaddr);
+    }
+
     LOG_ERROR(HW_Memory, "unknown GetPointer @ 0x%08x", vaddr);
     return nullptr;
 }
@@ -280,6 +335,97 @@ u8* GetPhysicalPointer(PAddr address) {
     return target_pointer;
 }
 
+void RasterizerMarkRegionCached(PAddr start, u64 size, int count_delta) {
+    if (start == 0) {
+        return;
+    }
+
+    u64 num_pages = ((start + size - 1) >> PAGE_BITS) - (start >> PAGE_BITS) + 1;
+    PAddr paddr = start;
+
+    for (unsigned i = 0; i < num_pages; ++i, paddr += PAGE_SIZE) {
+        boost::optional<VAddr> maybe_vaddr = PhysicalToVirtualAddress(paddr);
+        // While the physical <-> virtual mapping is 1:1 for the regions supported by the cache,
+        // some games (like Pokemon Super Mystery Dungeon) will try to use textures that go beyond
+        // the end address of VRAM, causing the Virtual->Physical translation to fail when flushing
+        // parts of the texture.
+        if (!maybe_vaddr) {
+            LOG_ERROR(HW_Memory,
+                      "Trying to flush a cached region to an invalid physical address %08X", paddr);
+            continue;
+        }
+        VAddr vaddr = *maybe_vaddr;
+
+        u8& res_count = current_page_table->cached_res_count[vaddr >> PAGE_BITS];
+        ASSERT_MSG(count_delta <= UINT8_MAX - res_count,
+                   "Rasterizer resource cache counter overflow!");
+        ASSERT_MSG(count_delta >= -res_count, "Rasterizer resource cache counter underflow!");
+
+        // Switch page type to cached if now cached
+        if (res_count == 0) {
+            PageType& page_type = current_page_table->attributes[vaddr >> PAGE_BITS];
+            switch (page_type) {
+            case PageType::Unmapped:
+                // It is not necessary for a process to have this region mapped into its address
+                // space, for example, a system module need not have a VRAM mapping.
+                break;
+            case PageType::Memory:
+                page_type = PageType::RasterizerCachedMemory;
+                current_page_table->pointers[vaddr >> PAGE_BITS] = nullptr;
+                break;
+            case PageType::Special:
+                page_type = PageType::RasterizerCachedSpecial;
+                break;
+            default:
+                UNREACHABLE();
+            }
+        }
+
+        res_count += count_delta;
+
+        // Switch page type to uncached if now uncached
+        if (res_count == 0) {
+            PageType& page_type = current_page_table->attributes[vaddr >> PAGE_BITS];
+            switch (page_type) {
+            case PageType::Unmapped:
+                // It is not necessary for a process to have this region mapped into its address
+                // space, for example, a system module need not have a VRAM mapping.
+                break;
+            case PageType::RasterizerCachedMemory: {
+                u8* pointer = GetPointerFromVMA(vaddr & ~PAGE_MASK);
+                if (pointer == nullptr) {
+                    // It's possible that this function has called been while updating the pagetable
+                    // after unmapping a VMA. In that case the underlying VMA will no longer exist,
+                    // and we should just leave the pagetable entry blank.
+                    page_type = PageType::Unmapped;
+                } else {
+                    page_type = PageType::Memory;
+                    current_page_table->pointers[vaddr >> PAGE_BITS] = pointer;
+                }
+                break;
+            }
+            case PageType::RasterizerCachedSpecial:
+                page_type = PageType::Special;
+                break;
+            default:
+                UNREACHABLE();
+            }
+        }
+    }
+}
+
+void RasterizerFlushRegion(PAddr start, u64 size) {}
+
+void RasterizerFlushAndInvalidateRegion(PAddr start, u64 size) {
+    // Since pages are unmapped on shutdown after video core is shutdown, the renderer may be
+    // null here
+}
+
+void RasterizerFlushVirtualRegion(VAddr start, u64 size, FlushMode mode) {
+    // Since pages are unmapped on shutdown after video core is shutdown, the renderer may be
+    // null here
+}
+
 u8 Read8(const VAddr addr) {
     return Read<u8>(addr);
 }
@@ -296,17 +442,6 @@ u64 Read64(const VAddr addr) {
     return Read<u64_le>(addr);
 }
 
-static bool ReadSpecialBlock(const Kernel::Process& process, const VAddr src_addr,
-                             void* dest_buffer, const size_t size) {
-    auto& page_table = process.vm_manager.page_table;
-    for (const auto& handler : GetSpecialHandlers(page_table, src_addr, size)) {
-        if (handler->ReadBlock(src_addr, dest_buffer, size)) {
-            return true;
-        }
-    }
-    return false;
-}
-
 void ReadBlock(const Kernel::Process& process, const VAddr src_addr, void* dest_buffer,
                const size_t size) {
     auto& page_table = process.vm_manager.page_table;
@@ -320,15 +455,11 @@ void ReadBlock(const Kernel::Process& process, const VAddr src_addr, void* dest_
         const VAddr current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
 
         switch (page_table.attributes[page_index]) {
-        case PageType::Unmapped:
+        case PageType::Unmapped: {
             LOG_ERROR(HW_Memory, "unmapped ReadBlock @ 0x%08X (start address = 0xllx, size = %zu)",
                       current_vaddr, src_addr, size);
             std::memset(dest_buffer, 0, copy_amount);
             break;
-        case PageType::Special: {
-            if (ReadSpecialBlock(process, current_vaddr, dest_buffer, copy_amount))
-                break;
-            [[fallthrough]];
         }
         case PageType::Memory: {
             DEBUG_ASSERT(page_table.pointers[page_index]);
@@ -337,6 +468,26 @@ void ReadBlock(const Kernel::Process& process, const VAddr src_addr, void* dest_
             std::memcpy(dest_buffer, src_ptr, copy_amount);
             break;
         }
+        case PageType::Special: {
+            MMIORegionPointer handler = GetMMIOHandler(page_table, current_vaddr);
+            DEBUG_ASSERT(handler);
+            handler->ReadBlock(current_vaddr, dest_buffer, copy_amount);
+            break;
+        }
+        case PageType::RasterizerCachedMemory: {
+            RasterizerFlushVirtualRegion(current_vaddr, static_cast<u32>(copy_amount),
+                                         FlushMode::Flush);
+            std::memcpy(dest_buffer, GetPointerFromVMA(process, current_vaddr), copy_amount);
+            break;
+        }
+        case PageType::RasterizerCachedSpecial: {
+            MMIORegionPointer handler = GetMMIOHandler(page_table, current_vaddr);
+            DEBUG_ASSERT(handler);
+            RasterizerFlushVirtualRegion(current_vaddr, static_cast<u32>(copy_amount),
+                                         FlushMode::Flush);
+            handler->ReadBlock(current_vaddr, dest_buffer, copy_amount);
+            break;
+        }
         default:
             UNREACHABLE();
         }
@@ -368,17 +519,6 @@ void Write64(const VAddr addr, const u64 data) {
     Write<u64_le>(addr, data);
 }
 
-static bool WriteSpecialBlock(const Kernel::Process& process, const VAddr dest_addr,
-                              const void* src_buffer, const size_t size) {
-    auto& page_table = process.vm_manager.page_table;
-    for (const auto& handler : GetSpecialHandlers(page_table, dest_addr, size)) {
-        if (handler->WriteBlock(dest_addr, src_buffer, size)) {
-            return true;
-        }
-    }
-    return false;
-}
-
 void WriteBlock(const Kernel::Process& process, const VAddr dest_addr, const void* src_buffer,
                 const size_t size) {
     auto& page_table = process.vm_manager.page_table;
@@ -391,15 +531,12 @@ void WriteBlock(const Kernel::Process& process, const VAddr dest_addr, const voi
         const VAddr current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
 
         switch (page_table.attributes[page_index]) {
-        case PageType::Unmapped:
+        case PageType::Unmapped: {
             LOG_ERROR(HW_Memory,
                       "unmapped WriteBlock @ 0x%08X (start address = 0x%08X, size = %zu)",
                       current_vaddr, dest_addr, size);
             break;
-        case PageType::Special:
-            if (WriteSpecialBlock(process, current_vaddr, src_buffer, copy_amount))
-                break;
-            [[fallthrough]];
+        }
         case PageType::Memory: {
             DEBUG_ASSERT(page_table.pointers[page_index]);
 
@@ -407,6 +544,26 @@ void WriteBlock(const Kernel::Process& process, const VAddr dest_addr, const voi
             std::memcpy(dest_ptr, src_buffer, copy_amount);
             break;
         }
+        case PageType::Special: {
+            MMIORegionPointer handler = GetMMIOHandler(page_table, current_vaddr);
+            DEBUG_ASSERT(handler);
+            handler->WriteBlock(current_vaddr, src_buffer, copy_amount);
+            break;
+        }
+        case PageType::RasterizerCachedMemory: {
+            RasterizerFlushVirtualRegion(current_vaddr, static_cast<u32>(copy_amount),
+                                         FlushMode::FlushAndInvalidate);
+            std::memcpy(GetPointerFromVMA(process, current_vaddr), src_buffer, copy_amount);
+            break;
+        }
+        case PageType::RasterizerCachedSpecial: {
+            MMIORegionPointer handler = GetMMIOHandler(page_table, current_vaddr);
+            DEBUG_ASSERT(handler);
+            RasterizerFlushVirtualRegion(current_vaddr, static_cast<u32>(copy_amount),
+                                         FlushMode::FlushAndInvalidate);
+            handler->WriteBlock(current_vaddr, src_buffer, copy_amount);
+            break;
+        }
         default:
             UNREACHABLE();
         }
@@ -423,8 +580,6 @@ void WriteBlock(const VAddr dest_addr, const void* src_buffer, const size_t size
 }
 
 void ZeroBlock(const VAddr dest_addr, const size_t size) {
-    const auto& process = *Kernel::g_current_process;
-
     size_t remaining_size = size;
     size_t page_index = dest_addr >> PAGE_BITS;
     size_t page_offset = dest_addr & PAGE_MASK;
@@ -436,14 +591,11 @@ void ZeroBlock(const VAddr dest_addr, const size_t size) {
         const VAddr current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
 
         switch (current_page_table->attributes[page_index]) {
-        case PageType::Unmapped:
+        case PageType::Unmapped: {
             LOG_ERROR(HW_Memory, "unmapped ZeroBlock @ 0x%08X (start address = 0x%08X, size = %zu)",
                       current_vaddr, dest_addr, size);
             break;
-        case PageType::Special:
-            if (WriteSpecialBlock(process, current_vaddr, zeros.data(), copy_amount))
-                break;
-            [[fallthrough]];
+        }
         case PageType::Memory: {
             DEBUG_ASSERT(current_page_table->pointers[page_index]);
 
@@ -451,6 +603,25 @@ void ZeroBlock(const VAddr dest_addr, const size_t size) {
             std::memset(dest_ptr, 0, copy_amount);
             break;
         }
+        case PageType::Special: {
+            DEBUG_ASSERT(GetMMIOHandler(current_vaddr));
+
+            GetMMIOHandler(current_vaddr)->WriteBlock(current_vaddr, zeros.data(), copy_amount);
+            break;
+        }
+        case PageType::RasterizerCachedMemory: {
+            RasterizerFlushVirtualRegion(current_vaddr, static_cast<u32>(copy_amount),
+                                         FlushMode::FlushAndInvalidate);
+            std::memset(GetPointerFromVMA(current_vaddr), 0, copy_amount);
+            break;
+        }
+        case PageType::RasterizerCachedSpecial: {
+            DEBUG_ASSERT(GetMMIOHandler(current_vaddr));
+            RasterizerFlushVirtualRegion(current_vaddr, static_cast<u32>(copy_amount),
+                                         FlushMode::FlushAndInvalidate);
+            GetMMIOHandler(current_vaddr)->WriteBlock(current_vaddr, zeros.data(), copy_amount);
+            break;
+        }
         default:
             UNREACHABLE();
         }
@@ -462,8 +633,6 @@ void ZeroBlock(const VAddr dest_addr, const size_t size) {
 }
 
 void CopyBlock(VAddr dest_addr, VAddr src_addr, const size_t size) {
-    const auto& process = *Kernel::g_current_process;
-
     size_t remaining_size = size;
     size_t page_index = src_addr >> PAGE_BITS;
     size_t page_offset = src_addr & PAGE_MASK;
@@ -473,18 +642,11 @@ void CopyBlock(VAddr dest_addr, VAddr src_addr, const size_t size) {
         const VAddr current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
 
         switch (current_page_table->attributes[page_index]) {
-        case PageType::Unmapped:
+        case PageType::Unmapped: {
             LOG_ERROR(HW_Memory, "unmapped CopyBlock @ 0x%08X (start address = 0x%08X, size = %zu)",
                       current_vaddr, src_addr, size);
             ZeroBlock(dest_addr, copy_amount);
             break;
-        case PageType::Special: {
-            std::vector<u8> buffer(copy_amount);
-            if (ReadSpecialBlock(process, current_vaddr, buffer.data(), buffer.size())) {
-                WriteBlock(dest_addr, buffer.data(), buffer.size());
-                break;
-            }
-            [[fallthrough]];
         }
         case PageType::Memory: {
             DEBUG_ASSERT(current_page_table->pointers[page_index]);
@@ -492,6 +654,30 @@ void CopyBlock(VAddr dest_addr, VAddr src_addr, const size_t size) {
             WriteBlock(dest_addr, src_ptr, copy_amount);
             break;
         }
+        case PageType::Special: {
+            DEBUG_ASSERT(GetMMIOHandler(current_vaddr));
+
+            std::vector<u8> buffer(copy_amount);
+            GetMMIOHandler(current_vaddr)->ReadBlock(current_vaddr, buffer.data(), buffer.size());
+            WriteBlock(dest_addr, buffer.data(), buffer.size());
+            break;
+        }
+        case PageType::RasterizerCachedMemory: {
+            RasterizerFlushVirtualRegion(current_vaddr, static_cast<u32>(copy_amount),
+                                         FlushMode::Flush);
+            WriteBlock(dest_addr, GetPointerFromVMA(current_vaddr), copy_amount);
+            break;
+        }
+        case PageType::RasterizerCachedSpecial: {
+            DEBUG_ASSERT(GetMMIOHandler(current_vaddr));
+            RasterizerFlushVirtualRegion(current_vaddr, static_cast<u32>(copy_amount),
+                                         FlushMode::Flush);
+
+            std::vector<u8> buffer(copy_amount);
+            GetMMIOHandler(current_vaddr)->ReadBlock(current_vaddr, buffer.data(), buffer.size());
+            WriteBlock(dest_addr, buffer.data(), buffer.size());
+            break;
+        }
         default:
             UNREACHABLE();
         }
@@ -505,75 +691,43 @@ void CopyBlock(VAddr dest_addr, VAddr src_addr, const size_t size) {
 }
 
 template <>
-boost::optional<u8> ReadSpecial<u8>(VAddr addr) {
-    const PageTable& page_table = Kernel::g_current_process->vm_manager.page_table;
-    for (const auto& handler : GetSpecialHandlers(page_table, addr, sizeof(u8)))
-        if (auto result = handler->Read8(addr))
-            return *result;
-    return {};
+u8 ReadMMIO<u8>(MMIORegionPointer mmio_handler, VAddr addr) {
+    return mmio_handler->Read8(addr);
 }
 
 template <>
-boost::optional<u16> ReadSpecial<u16>(VAddr addr) {
-    const PageTable& page_table = Kernel::g_current_process->vm_manager.page_table;
-    for (const auto& handler : GetSpecialHandlers(page_table, addr, sizeof(u16)))
-        if (auto result = handler->Read16(addr))
-            return *result;
-    return {};
+u16 ReadMMIO<u16>(MMIORegionPointer mmio_handler, VAddr addr) {
+    return mmio_handler->Read16(addr);
 }
 
 template <>
-boost::optional<u32> ReadSpecial<u32>(VAddr addr) {
-    const PageTable& page_table = Kernel::g_current_process->vm_manager.page_table;
-    for (const auto& handler : GetSpecialHandlers(page_table, addr, sizeof(u32)))
-        if (auto result = handler->Read32(addr))
-            return *result;
-    return {};
+u32 ReadMMIO<u32>(MMIORegionPointer mmio_handler, VAddr addr) {
+    return mmio_handler->Read32(addr);
 }
 
 template <>
-boost::optional<u64> ReadSpecial<u64>(VAddr addr) {
-    const PageTable& page_table = Kernel::g_current_process->vm_manager.page_table;
-    for (const auto& handler : GetSpecialHandlers(page_table, addr, sizeof(u64)))
-        if (auto result = handler->Read64(addr))
-            return *result;
-    return {};
+u64 ReadMMIO<u64>(MMIORegionPointer mmio_handler, VAddr addr) {
+    return mmio_handler->Read64(addr);
 }
 
 template <>
-bool WriteSpecial<u8>(VAddr addr, const u8 data) {
-    const PageTable& page_table = Kernel::g_current_process->vm_manager.page_table;
-    for (const auto& handler : GetSpecialHandlers(page_table, addr, sizeof(u8)))
-        if (handler->Write8(addr, data))
-            return true;
-    return false;
+void WriteMMIO<u8>(MMIORegionPointer mmio_handler, VAddr addr, const u8 data) {
+    mmio_handler->Write8(addr, data);
 }
 
 template <>
-bool WriteSpecial<u16>(VAddr addr, const u16 data) {
-    const PageTable& page_table = Kernel::g_current_process->vm_manager.page_table;
-    for (const auto& handler : GetSpecialHandlers(page_table, addr, sizeof(u16)))
-        if (handler->Write16(addr, data))
-            return true;
-    return false;
+void WriteMMIO<u16>(MMIORegionPointer mmio_handler, VAddr addr, const u16 data) {
+    mmio_handler->Write16(addr, data);
 }
 
 template <>
-bool WriteSpecial<u32>(VAddr addr, const u32 data) {
-    const PageTable& page_table = Kernel::g_current_process->vm_manager.page_table;
-    for (const auto& handler : GetSpecialHandlers(page_table, addr, sizeof(u32)))
-        if (handler->Write32(addr, data))
-            return true;
-    return false;
+void WriteMMIO<u32>(MMIORegionPointer mmio_handler, VAddr addr, const u32 data) {
+    mmio_handler->Write32(addr, data);
 }
 
 template <>
-bool WriteSpecial<u64>(VAddr addr, const u64 data) {
-    const PageTable& page_table = Kernel::g_current_process->vm_manager.page_table;
-    for (const auto& handler : GetSpecialHandlers(page_table, addr, sizeof(u64)))
-        if (handler->Write64(addr, data))
-            return true;
-    return false;
+void WriteMMIO<u64>(MMIORegionPointer mmio_handler, VAddr addr, const u64 data) {
+    mmio_handler->Write64(addr, data);
 }
 
 boost::optional<PAddr> TryVirtualToPhysicalAddress(const VAddr addr) {

src/core/memory.h

@@ -8,12 +8,10 @@
 #include <cstddef>
 #include <map>
 #include <string>
-#include <tuple>
 #include <vector>
-#include <boost/icl/interval_map.hpp>
 #include <boost/optional.hpp>
 #include "common/common_types.h"
-#include "core/memory_hook.h"
+#include "core/mmio.h"
 
 namespace Kernel {
 class Process;
@@ -30,35 +28,32 @@ const u64 PAGE_SIZE = 1 << PAGE_BITS;
 const u64 PAGE_MASK = PAGE_SIZE - 1;
 const size_t PAGE_TABLE_NUM_ENTRIES = 1ULL << (36 - PAGE_BITS);
 
-enum class PageType : u8 {
+enum class PageType {
     /// Page is unmapped and should cause an access error.
     Unmapped,
     /// Page is mapped to regular memory. This is the only type you can get pointers to.
     Memory,
-    /// Page is mapped to a memory hook, which intercepts read and write requests.
+    /// Page is mapped to regular memory, but also needs to check for rasterizer cache flushing and
+    /// invalidation
+    RasterizerCachedMemory,
+    /// Page is mapped to a I/O region. Writing and reading to this page is handled by functions.
     Special,
+    /// Page is mapped to a I/O region, but also needs to check for rasterizer cache flushing and
+    /// invalidation
+    RasterizerCachedSpecial,
 };
 
 struct SpecialRegion {
-    enum class Type {
-        DebugHook,
-        IODevice,
-    } type;
-
-    MemoryHookPointer handler;
-
-    bool operator<(const SpecialRegion& other) const {
-        return std::tie(type, handler) < std::tie(other.type, other.handler);
-    }
-
-    bool operator==(const SpecialRegion& other) const {
-        return std::tie(type, handler) == std::tie(other.type, other.handler);
-    }
+    VAddr base;
+    u64 size;
+    MMIORegionPointer handler;
 };
 
 /**
  * A (reasonably) fast way of allowing switchable and remappable process address spaces. It loosely
- * mimics the way a real CPU page table works.
+ * mimics the way a real CPU page table works, but instead is optimized for minimal decoding and
+ * fetching requirements when accessing. In the usual case of an access to regular memory, it only
+ * requires an indexed fetch and a check for NULL.
  */
 struct PageTable {
     /**
@@ -71,13 +66,19 @@ struct PageTable {
      * Contains MMIO handlers that back memory regions whose entries in the `attribute` array is of
      * type `Special`.
      */
-    boost::icl::interval_map<VAddr, std::set<SpecialRegion>> special_regions;
+    std::vector<SpecialRegion> special_regions;
 
     /**
      * Array of fine grained page attributes. If it is set to any value other than `Memory`, then
      * the corresponding entry in `pointers` MUST be set to null.
      */
     std::array<PageType, PAGE_TABLE_NUM_ENTRIES> attributes;
+
+    /**
+     * Indicates the number of externally cached resources touching a page that should be
+     * flushed before the memory is accessed
+     */
+    std::array<u8, PAGE_TABLE_NUM_ENTRIES> cached_res_count;
 };
 
 /// Physical memory regions as seen from the ARM11
@@ -242,4 +243,33 @@ boost::optional<VAddr> PhysicalToVirtualAddress(PAddr addr);
  */
 u8* GetPhysicalPointer(PAddr address);
 
+/**
+ * Adds the supplied value to the rasterizer resource cache counter of each
+ * page touching the region.
+ */
+void RasterizerMarkRegionCached(PAddr start, u64 size, int count_delta);
+
+/**
+ * Flushes any externally cached rasterizer resources touching the given region.
+ */
+void RasterizerFlushRegion(PAddr start, u64 size);
+
+/**
+ * Flushes and invalidates any externally cached rasterizer resources touching the given region.
+ */
+void RasterizerFlushAndInvalidateRegion(PAddr start, u64 size);
+
+enum class FlushMode {
+    /// Write back modified surfaces to RAM
+    Flush,
+    /// Write back modified surfaces to RAM, and also remove them from the cache
+    FlushAndInvalidate,
+};
+
+/**
+ * Flushes and invalidates any externally cached rasterizer resources touching the given virtual
+ * address region.
+ */
+void RasterizerFlushVirtualRegion(VAddr start, u64 size, FlushMode mode);
+
 } // namespace Memory

src/core/memory_hook.h

@@ -1,46 +0,0 @@
-// Copyright 2016 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <boost/optional.hpp>
-#include "common/common_types.h"
-
-namespace Memory {
-
-/**
- * Memory hooks have two purposes:
- * 1. To allow reads and writes to a region of memory to be intercepted. This is used to implement
- *    texture forwarding and memory breakpoints for debugging.
- * 2. To allow for the implementation of MMIO devices.
- *
- * A hook may be mapped to multiple regions of memory.
- *
- * If a boost::none or false is returned from a function, the read/write request is passed through
- * to the underlying memory region.
- */
-class MemoryHook {
-public:
-    virtual ~MemoryHook() = default;
-
-    virtual boost::optional<bool> IsValidAddress(VAddr addr) = 0;
-
-    virtual boost::optional<u8> Read8(VAddr addr) = 0;
-    virtual boost::optional<u16> Read16(VAddr addr) = 0;
-    virtual boost::optional<u32> Read32(VAddr addr) = 0;
-    virtual boost::optional<u64> Read64(VAddr addr) = 0;
-
-    virtual bool ReadBlock(VAddr src_addr, void* dest_buffer, size_t size) = 0;
-
-    virtual bool Write8(VAddr addr, u8 data) = 0;
-    virtual bool Write16(VAddr addr, u16 data) = 0;
-    virtual bool Write32(VAddr addr, u32 data) = 0;
-    virtual bool Write64(VAddr addr, u64 data) = 0;
-
-    virtual bool WriteBlock(VAddr dest_addr, const void* src_buffer, size_t size) = 0;
-};
-
-using MemoryHookPointer = std::shared_ptr<MemoryHook>;
-} // namespace Memory

src/core/memory_setup.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #include "common/common_types.h"
-#include "core/memory_hook.h"
+#include "core/mmio.h"
 
 namespace Memory {
 
@@ -26,11 +26,7 @@ void MapMemoryRegion(PageTable& page_table, VAddr base, u64 size, u8* target);
  * @param size The amount of bytes to map. Must be page-aligned.
  * @param mmio_handler The handler that backs the mapping.
  */
-void MapIoRegion(PageTable& page_table, VAddr base, u64 size, MemoryHookPointer mmio_handler);
+void MapIoRegion(PageTable& page_table, VAddr base, u64 size, MMIORegionPointer mmio_handler);
 
 void UnmapRegion(PageTable& page_table, VAddr base, u64 size);
-
-void AddDebugHook(PageTable& page_table, VAddr base, u64 size, MemoryHookPointer hook);
-void RemoveDebugHook(PageTable& page_table, VAddr base, u64 size, MemoryHookPointer hook);
-
 } // namespace Memory

src/core/mmio.h

@@ -0,0 +1,38 @@
+// Copyright 2016 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include "common/common_types.h"
+
+namespace Memory {
+
+/**
+ * Represents a device with memory mapped IO.
+ * A device may be mapped to multiple regions of memory.
+ */
+class MMIORegion {
+public:
+    virtual ~MMIORegion() = default;
+
+    virtual bool IsValidAddress(VAddr addr) = 0;
+
+    virtual u8 Read8(VAddr addr) = 0;
+    virtual u16 Read16(VAddr addr) = 0;
+    virtual u32 Read32(VAddr addr) = 0;
+    virtual u64 Read64(VAddr addr) = 0;
+
+    virtual bool ReadBlock(VAddr src_addr, void* dest_buffer, size_t size) = 0;
+
+    virtual void Write8(VAddr addr, u8 data) = 0;
+    virtual void Write16(VAddr addr, u16 data) = 0;
+    virtual void Write32(VAddr addr, u32 data) = 0;
+    virtual void Write64(VAddr addr, u64 data) = 0;
+
+    virtual bool WriteBlock(VAddr dest_addr, const void* src_buffer, size_t size) = 0;
+};
+
+using MMIORegionPointer = std::shared_ptr<MMIORegion>;
+}; // namespace Memory

src/tests/core/arm/arm_test_common.cpp

@@ -19,8 +19,8 @@ TestEnvironment::TestEnvironment(bool mutable_memory_)
     page_table = &Kernel::g_current_process->vm_manager.page_table;
 
     page_table->pointers.fill(nullptr);
-    page_table->special_regions.clear();
     page_table->attributes.fill(Memory::PageType::Unmapped);
+    page_table->cached_res_count.fill(0);
 
     Memory::MapIoRegion(*page_table, 0x00000000, 0x80000000, test_memory);
     Memory::MapIoRegion(*page_table, 0x80000000, 0x80000000, test_memory);
@@ -62,11 +62,11 @@ void TestEnvironment::ClearWriteRecords() {
 
 TestEnvironment::TestMemory::~TestMemory() {}
 
-boost::optional<bool> TestEnvironment::TestMemory::IsValidAddress(VAddr addr) {
+bool TestEnvironment::TestMemory::IsValidAddress(VAddr addr) {
     return true;
 }
 
-boost::optional<u8> TestEnvironment::TestMemory::Read8(VAddr addr) {
+u8 TestEnvironment::TestMemory::Read8(VAddr addr) {
     auto iter = data.find(addr);
     if (iter == data.end()) {
         return addr; // Some arbitrary data
@@ -74,16 +74,16 @@ boost::optional<u8> TestEnvironment::TestMemory::Read8(VAddr addr) {
     return iter->second;
 }
 
-boost::optional<u16> TestEnvironment::TestMemory::Read16(VAddr addr) {
-    return *Read8(addr) | static_cast<u16>(*Read8(addr + 1)) << 8;
+u16 TestEnvironment::TestMemory::Read16(VAddr addr) {
+    return Read8(addr) | static_cast<u16>(Read8(addr + 1)) << 8;
 }
 
-boost::optional<u32> TestEnvironment::TestMemory::Read32(VAddr addr) {
-    return *Read16(addr) | static_cast<u32>(*Read16(addr + 2)) << 16;
+u32 TestEnvironment::TestMemory::Read32(VAddr addr) {
+    return Read16(addr) | static_cast<u32>(Read16(addr + 2)) << 16;
 }
 
-boost::optional<u64> TestEnvironment::TestMemory::Read64(VAddr addr) {
-    return *Read32(addr) | static_cast<u64>(*Read32(addr + 4)) << 32;
+u64 TestEnvironment::TestMemory::Read64(VAddr addr) {
+    return Read32(addr) | static_cast<u64>(Read32(addr + 4)) << 32;
 }
 
 bool TestEnvironment::TestMemory::ReadBlock(VAddr src_addr, void* dest_buffer, size_t size) {
@@ -91,38 +91,34 @@ bool TestEnvironment::TestMemory::ReadBlock(VAddr src_addr, void* dest_buffer, s
     u8* data = static_cast<u8*>(dest_buffer);
 
     for (size_t i = 0; i < size; i++, addr++, data++) {
-        *data = *Read8(addr);
+        *data = Read8(addr);
     }
 
     return true;
 }
 
-bool TestEnvironment::TestMemory::Write8(VAddr addr, u8 data) {
+void TestEnvironment::TestMemory::Write8(VAddr addr, u8 data) {
     env->write_records.emplace_back(8, addr, data);
     if (env->mutable_memory)
         env->SetMemory8(addr, data);
-    return true;
 }
 
-bool TestEnvironment::TestMemory::Write16(VAddr addr, u16 data) {
+void TestEnvironment::TestMemory::Write16(VAddr addr, u16 data) {
     env->write_records.emplace_back(16, addr, data);
     if (env->mutable_memory)
         env->SetMemory16(addr, data);
-    return true;
 }
 
-bool TestEnvironment::TestMemory::Write32(VAddr addr, u32 data) {
+void TestEnvironment::TestMemory::Write32(VAddr addr, u32 data) {
     env->write_records.emplace_back(32, addr, data);
     if (env->mutable_memory)
         env->SetMemory32(addr, data);
-    return true;
 }
 
-bool TestEnvironment::TestMemory::Write64(VAddr addr, u64 data) {
+void TestEnvironment::TestMemory::Write64(VAddr addr, u64 data) {
     env->write_records.emplace_back(64, addr, data);
     if (env->mutable_memory)
         env->SetMemory64(addr, data);
-    return true;
 }
 
 bool TestEnvironment::TestMemory::WriteBlock(VAddr dest_addr, const void* src_buffer, size_t size) {

src/tests/core/arm/arm_test_common.h

@@ -7,7 +7,7 @@
 #include <vector>
 
 #include "common/common_types.h"
-#include "core/memory_hook.h"
+#include "core/mmio.h"
 
 namespace ArmTests {
 
@@ -51,25 +51,25 @@ public:
 
 private:
     friend struct TestMemory;
-    struct TestMemory final : Memory::MemoryHook {
+    struct TestMemory final : Memory::MMIORegion {
         explicit TestMemory(TestEnvironment* env_) : env(env_) {}
         TestEnvironment* env;
 
         ~TestMemory() override;
 
-        boost::optional<bool> IsValidAddress(VAddr addr) override;
+        bool IsValidAddress(VAddr addr) override;
 
-        boost::optional<u8> Read8(VAddr addr) override;
-        boost::optional<u16> Read16(VAddr addr) override;
-        boost::optional<u32> Read32(VAddr addr) override;
-        boost::optional<u64> Read64(VAddr addr) override;
+        u8 Read8(VAddr addr) override;
+        u16 Read16(VAddr addr) override;
+        u32 Read32(VAddr addr) override;
+        u64 Read64(VAddr addr) override;
 
         bool ReadBlock(VAddr src_addr, void* dest_buffer, size_t size) override;
 
-        bool Write8(VAddr addr, u8 data) override;
-        bool Write16(VAddr addr, u16 data) override;
-        bool Write32(VAddr addr, u32 data) override;
-        bool Write64(VAddr addr, u64 data) override;
+        void Write8(VAddr addr, u8 data) override;
+        void Write16(VAddr addr, u16 data) override;
+        void Write32(VAddr addr, u32 data) override;
+        void Write64(VAddr addr, u64 data) override;
 
         bool WriteBlock(VAddr dest_addr, const void* src_buffer, size_t size) override;