Service/hid: stub some functions

pl_u: Add basic support for shared fonts.

src/common/logging/backend.cpp

@@ -40,6 +40,7 @@ namespace Log {
     SUB(Service, HID)                                                                              \
     SUB(Service, LM)                                                                               \
     SUB(Service, NIFM)                                                                             \
+    SUB(Service, NS)                                                                               \
     SUB(Service, NVDRV)                                                                            \
     SUB(Service, PCTL)                                                                             \
     SUB(Service, SET)                                                                              \

src/common/logging/log.h

@@ -57,6 +57,7 @@ enum class Class : ClassType {
     Service_HID,       ///< The HID (Human interface device) service
     Service_LM,        ///< The LM (Logger) service
     Service_NIFM,      ///< The NIFM (Network interface) service
+    Service_NS,        ///< The NS services
     Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
     Service_PCTL,      ///< The PCTL (Parental control) service
     Service_SET,       ///< The SET (Settings) service

src/core/CMakeLists.txt

@@ -124,6 +124,10 @@ add_library(core STATIC
     hle/service/nifm/nifm_s.h
     hle/service/nifm/nifm_u.cpp
     hle/service/nifm/nifm_u.h
+    hle/service/ns/ns.cpp
+    hle/service/ns/ns.h
+    hle/service/ns/pl_u.cpp
+    hle/service/ns/pl_u.h
     hle/service/nvdrv/devices/nvdevice.h
     hle/service/nvdrv/devices/nvdisp_disp0.cpp
     hle/service/nvdrv/devices/nvdisp_disp0.h

src/core/arm/arm_interface.h

@@ -25,11 +25,19 @@ public:
         VAddr tls_address;
     };
 
-    /// Runs the CPU until an event happens
-    virtual void Run() = 0;
+    /**
+     * Runs the CPU for the given number of instructions
+     * @param num_instructions Number of instructions to run
+     */
+    void Run(int num_instructions) {
+        ExecuteInstructions(num_instructions);
+        this->num_instructions += num_instructions;
+    }
 
     /// Step CPU by one instruction
-    virtual void Step() = 0;
+    void Step() {
+        Run(1);
+    }
 
     virtual void MapBackingMemory(VAddr address, size_t size, u8* memory,
                                   Kernel::VMAPermission perms) {}
@@ -114,4 +122,19 @@ public:
 
     /// Prepare core for thread reschedule (if needed to correctly handle state)
     virtual void PrepareReschedule() = 0;
+
+    /// Getter for num_instructions
+    u64 GetNumInstructions() const {
+        return num_instructions;
+    }
+
+protected:
+    /**
+     * Executes the given number of instructions
+     * @param num_instructions Number of instructions to executes
+     */
+    virtual void ExecuteInstructions(int num_instructions) = 0;
+
+private:
+    u64 num_instructions = 0; ///< Number of instructions executed
 };

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -101,22 +101,11 @@ std::unique_ptr<Dynarmic::A64::Jit> MakeJit(const std::unique_ptr<ARM_Dynarmic_C
     return std::make_unique<Dynarmic::A64::Jit>(config);
 }
 
-void ARM_Dynarmic::Run() {
-    ASSERT(Memory::GetCurrentPageTable() == current_page_table);
-
-    jit->Run();
-}
-
-void ARM_Dynarmic::Step() {
-    cb->InterpreterFallback(jit->GetPC(), 1);
-}
-
 ARM_Dynarmic::ARM_Dynarmic()
     : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), jit(MakeJit(cb)) {
     ARM_Interface::ThreadContext ctx;
     inner_unicorn.SaveContext(ctx);
     LoadContext(ctx);
-    PageTableChanged();
 }
 
 ARM_Dynarmic::~ARM_Dynarmic() = default;
@@ -175,6 +164,13 @@ void ARM_Dynarmic::SetTlsAddress(u64 address) {
     cb->tpidrro_el0 = address;
 }
 
+void ARM_Dynarmic::ExecuteInstructions(int num_instructions) {
+    cb->ticks_remaining = num_instructions;
+    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();
@@ -207,5 +203,4 @@ void ARM_Dynarmic::ClearInstructionCache() {
 
 void ARM_Dynarmic::PageTableChanged() {
     jit = MakeJit(cb);
-    current_page_table = Memory::GetCurrentPageTable();
 }

src/core/arm/dynarmic/arm_dynarmic.h

@@ -29,8 +29,6 @@ public:
     u32 GetVFPReg(int index) const override;
     void SetVFPReg(int index, u32 value) override;
     u32 GetCPSR() const override;
-    void Run() override;
-    void Step() override;
     void SetCPSR(u32 cpsr) override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
@@ -39,6 +37,7 @@ public:
     void LoadContext(const ThreadContext& ctx) override;
 
     void PrepareReschedule() override;
+    void ExecuteInstructions(int num_instructions) override;
 
     void ClearInstructionCache() override;
     void PageTableChanged() override;
@@ -48,6 +47,4 @@ private:
     std::unique_ptr<ARM_Dynarmic_Callbacks> cb;
     std::unique_ptr<Dynarmic::A64::Jit> jit;
     ARM_Unicorn inner_unicorn;
-
-    Memory::PageTable* current_page_table = nullptr;
 };

src/core/arm/unicorn/arm_unicorn.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
 #include <unicorn/arm64.h>
 #include "common/assert.h"
 #include "common/microprofile.h"
@@ -149,14 +148,6 @@ void ARM_Unicorn::SetTlsAddress(VAddr base) {
     CHECKED(uc_reg_write(uc, UC_ARM64_REG_TPIDRRO_EL0, &base));
 }
 
-void ARM_Unicorn::Run() {
-    ExecuteInstructions(std::max(CoreTiming::GetDowncount(), 0));
-}
-
-void ARM_Unicorn::Step() {
-    ExecuteInstructions(1);
-}
-
 MICROPROFILE_DEFINE(ARM_Jit, "ARM JIT", "ARM JIT", MP_RGB(255, 64, 64));
 
 void ARM_Unicorn::ExecuteInstructions(int num_instructions) {

src/core/arm/unicorn/arm_unicorn.h

@@ -29,9 +29,7 @@ public:
     void SaveContext(ThreadContext& ctx) override;
     void LoadContext(const ThreadContext& ctx) override;
     void PrepareReschedule() override;
-    void ExecuteInstructions(int num_instructions);
-    void Run() override;
-    void Step() override;
+    void ExecuteInstructions(int num_instructions) override;
     void ClearInstructionCache() override;
     void PageTableChanged() override{};
 

src/core/core.cpp

@@ -26,7 +26,7 @@ namespace Core {
 
 /*static*/ System System::s_instance;
 
-System::ResultStatus System::RunLoop(bool tight_loop) {
+System::ResultStatus System::RunLoop(int tight_loop) {
     status = ResultStatus::Success;
     if (!cpu_core) {
         return ResultStatus::ErrorNotInitialized;
@@ -40,7 +40,7 @@ System::ResultStatus System::RunLoop(bool tight_loop) {
         if (GDBStub::GetCpuHaltFlag()) {
             if (GDBStub::GetCpuStepFlag()) {
                 GDBStub::SetCpuStepFlag(false);
-                tight_loop = false;
+                tight_loop = 1;
             } else {
                 return ResultStatus::Success;
             }
@@ -56,11 +56,7 @@ System::ResultStatus System::RunLoop(bool tight_loop) {
         PrepareReschedule();
     } else {
         CoreTiming::Advance();
-        if (tight_loop) {
-            cpu_core->Run();
-        } else {
-            cpu_core->Step();
-        }
+        cpu_core->Run(tight_loop);
     }
 
     HW::Update();
@@ -70,7 +66,7 @@ System::ResultStatus System::RunLoop(bool tight_loop) {
 }
 
 System::ResultStatus System::SingleStep() {
-    return RunLoop(false);
+    return RunLoop(1);
 }
 
 System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& filepath) {

src/core/core.h

@@ -51,10 +51,10 @@ public:
      * is not required to do a full dispatch with each instruction. NOTE: the number of instructions
      * requested is not guaranteed to run, as this will be interrupted preemptively if a hardware
      * update is requested (e.g. on a thread switch).
-     * @param tight_loop If false, the CPU single-steps.
+     * @param tight_loop Number of instructions to execute.
      * @return Result status, indicating whether or not the operation succeeded.
      */
-    ResultStatus RunLoop(bool tight_loop = true);
+    ResultStatus RunLoop(int tight_loop = 100000);
 
     /**
      * Step the CPU one instruction

src/core/hle/ipc.h

@@ -91,6 +91,10 @@ struct BufferDescriptorX {
         address |= static_cast<VAddr>(address_bits_36_38) << 36;
         return address;
     }
+
+    u64 Size() const {
+        return static_cast<u64>(size);
+    }
 };
 static_assert(sizeof(BufferDescriptorX) == 8, "BufferDescriptorX size is incorrect");
 

src/core/hle/kernel/hle_ipc.cpp

@@ -12,6 +12,7 @@
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/server_session.h"
+#include "core/memory.h"
 
 namespace Kernel {
 
@@ -210,4 +211,98 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(u32_le* dst_cmdbuf, P
     return RESULT_SUCCESS;
 }
 
+std::vector<u8> HLERequestContext::ReadBuffer() const {
+    std::vector<u8> buffer;
+    const bool is_buffer_a{BufferDescriptorA().size() && BufferDescriptorA()[0].Size()};
+
+    if (is_buffer_a) {
+        buffer.resize(BufferDescriptorA()[0].Size());
+        Memory::ReadBlock(BufferDescriptorA()[0].Address(), buffer.data(), buffer.size());
+    } else {
+        buffer.resize(BufferDescriptorX()[0].Size());
+        Memory::ReadBlock(BufferDescriptorX()[0].Address(), buffer.data(), buffer.size());
+    }
+
+    return buffer;
+}
+
+size_t HLERequestContext::WriteBuffer(const void* buffer, size_t size) const {
+    const bool is_buffer_b{BufferDescriptorB().size() && BufferDescriptorB()[0].Size()};
+
+    ASSERT_MSG(size <= GetWriteBufferSize(), "Size %d is too big", size);
+
+    if (is_buffer_b) {
+        Memory::WriteBlock(BufferDescriptorB()[0].Address(), buffer, size);
+    } else {
+        Memory::WriteBlock(BufferDescriptorC()[0].Address(), buffer, size);
+    }
+
+    return size;
+}
+
+size_t HLERequestContext::WriteBuffer(const std::vector<u8>& buffer) const {
+    return WriteBuffer(buffer.data(), buffer.size());
+}
+
+size_t HLERequestContext::GetReadBufferSize() const {
+    const bool is_buffer_a{BufferDescriptorA().size() && BufferDescriptorA()[0].Size()};
+    return is_buffer_a ? BufferDescriptorA()[0].Size() : BufferDescriptorX()[0].Size();
+}
+
+size_t HLERequestContext::GetWriteBufferSize() const {
+    const bool is_buffer_b{BufferDescriptorB().size() && BufferDescriptorB()[0].Size()};
+    return is_buffer_b ? BufferDescriptorB()[0].Size() : BufferDescriptorC()[0].Size();
+}
+
+std::string HLERequestContext::Description() const {
+    if (!command_header) {
+        return "No command header available";
+    }
+    std::ostringstream s;
+    s << "IPC::CommandHeader: Type:" << static_cast<u32>(command_header->type.Value());
+    s << ", X(Pointer):" << command_header->num_buf_x_descriptors;
+    if (command_header->num_buf_x_descriptors) {
+        s << '[';
+        for (u64 i = 0; i < command_header->num_buf_x_descriptors; ++i) {
+            s << "0x" << std::hex << BufferDescriptorX()[i].Size();
+            if (i < command_header->num_buf_x_descriptors - 1)
+                s << ", ";
+        }
+        s << ']';
+    }
+    s << ", A(Send):" << command_header->num_buf_a_descriptors;
+    if (command_header->num_buf_a_descriptors) {
+        s << '[';
+        for (u64 i = 0; i < command_header->num_buf_a_descriptors; ++i) {
+            s << "0x" << std::hex << BufferDescriptorA()[i].Size();
+            if (i < command_header->num_buf_a_descriptors - 1)
+                s << ", ";
+        }
+        s << ']';
+    }
+    s << ", B(Receive):" << command_header->num_buf_b_descriptors;
+    if (command_header->num_buf_b_descriptors) {
+        s << '[';
+        for (u64 i = 0; i < command_header->num_buf_b_descriptors; ++i) {
+            s << "0x" << std::hex << BufferDescriptorB()[i].Size();
+            if (i < command_header->num_buf_b_descriptors - 1)
+                s << ", ";
+        }
+        s << ']';
+    }
+    s << ", C(ReceiveList):" << BufferDescriptorC().size();
+    if (!BufferDescriptorC().empty()) {
+        s << '[';
+        for (u64 i = 0; i < BufferDescriptorC().size(); ++i) {
+            s << "0x" << std::hex << BufferDescriptorC()[i].Size();
+            if (i < BufferDescriptorC().size() - 1)
+                s << ", ";
+        }
+        s << ']';
+    }
+    s << ", data_size:" << command_header->data_size.Value();
+
+    return s.str();
+}
+
 } // namespace Kernel

src/core/hle/kernel/hle_ipc.h

@@ -143,6 +143,21 @@ public:
         return domain_message_header;
     }
 
+    /// Helper function to read a buffer using the appropriate buffer descriptor
+    std::vector<u8> ReadBuffer() const;
+
+    /// Helper function to write a buffer using the appropriate buffer descriptor
+    size_t WriteBuffer(const void* buffer, size_t size) const;
+
+    /// Helper function to write a buffer using the appropriate buffer descriptor
+    size_t WriteBuffer(const std::vector<u8>& buffer) const;
+
+    /// Helper function to get the size of the input buffer
+    size_t GetReadBufferSize() const;
+
+    /// Helper function to get the size of the output buffer
+    size_t GetWriteBufferSize() const;
+
     template <typename T>
     SharedPtr<T> GetCopyObject(size_t index) {
         ASSERT(index < copy_objects.size());
@@ -187,6 +202,8 @@ public:
         return domain_objects.size();
     }
 
+    std::string Description() const;
+
 private:
     std::array<u32, IPC::COMMAND_BUFFER_LENGTH> cmd_buf;
     SharedPtr<Kernel::ServerSession> server_session;

src/core/hle/kernel/shared_memory.cpp

@@ -111,13 +111,6 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
         return ERR_INVALID_COMBINATION;
     }
 
-    // Heap-backed memory blocks can not be mapped with other_permissions = DontCare
-    if (base_address != 0 && other_permissions == MemoryPermission::DontCare) {
-        LOG_ERROR(Kernel, "cannot map id=%u, address=0x%llx name=%s, permissions don't match",
-                  GetObjectId(), address, name.c_str());
-        return ERR_INVALID_COMBINATION;
-    }
-
     // Error out if the provided permissions are not compatible with what the creator process needs.
     if (other_permissions != MemoryPermission::DontCare &&
         static_cast<u32>(this->permissions) & ~static_cast<u32>(other_permissions)) {
@@ -126,12 +119,6 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
         return ERR_WRONG_PERMISSION;
     }
 
-    // TODO(Subv): Check for the Shared Device Mem flag in the creator process.
-    /*if (was_created_with_shared_device_mem && address != 0) {
-        return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::OS,
-    ErrorSummary::InvalidArgument, ErrorLevel::Usage);
-    }*/
-
     // TODO(Subv): The same process that created a SharedMemory object
     // can not map it in its own address space unless it was created with addr=0, result 0xD900182C.
 

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

@@ -66,8 +66,7 @@ void ACC_U0::GetUserExistence(Kernel::HLERequestContext& ctx) {
 
 void ACC_U0::ListAllUsers(Kernel::HLERequestContext& ctx) {
     constexpr std::array<u128, 10> user_ids{DEFAULT_USER_ID};
-    const auto& output_buffer = ctx.BufferDescriptorC()[0];
-    Memory::WriteBlock(output_buffer.Address(), user_ids.data(), user_ids.size());
+    ctx.WriteBuffer(user_ids.data(), user_ids.size());
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
     LOG_DEBUG(Service_ACC, "called");

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

@@ -306,11 +306,11 @@ private:
 
         u64 offset = rp.Pop<u64>();
 
-        const auto& output_buffer = ctx.BufferDescriptorC()[0];
+        const size_t size{ctx.GetWriteBufferSize()};
 
-        ASSERT(offset + output_buffer.Size() <= buffer.size());
+        ASSERT(offset + size <= buffer.size());
 
-        Memory::WriteBlock(output_buffer.Address(), buffer.data() + offset, output_buffer.Size());
+        ctx.WriteBuffer(buffer.data() + offset, size);
 
         IPC::ResponseBuilder rb{ctx, 2};
 

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

@@ -99,8 +99,6 @@ private:
     void GetReleasedAudioOutBuffer_1(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
 
-        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
         // is used to know which buffer should be filled with data and send again to the service
@@ -112,7 +110,7 @@ private:
             queue_keys.pop_back();
         }
 
-        Memory::WriteBlock(buffer.Address(), &key, sizeof(u64));
+        ctx.WriteBuffer(&key, sizeof(u64));
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
@@ -158,10 +156,8 @@ void AudOutU::ListAudioOuts(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_Audio, "(STUBBED) called");
     IPC::RequestParser rp{ctx};
 
-    auto& buffer = ctx.BufferDescriptorB()[0];
     const std::string audio_interface = "AudioInterface";
-
-    Memory::WriteBlock(buffer.Address(), &audio_interface[0], audio_interface.size());
+    ctx.WriteBuffer(audio_interface.c_str(), audio_interface.size());
 
     IPC::ResponseBuilder rb = rp.MakeBuilder(3, 0, 0);
 

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

@@ -53,7 +53,8 @@ private:
     }
 
     void RequestUpdateAudioRenderer(Kernel::HLERequestContext& ctx) {
-        AudioRendererResponseData response_data = {0};
+        LOG_DEBUG(Service_Audio, "%s", ctx.Description().c_str());
+        AudioRendererResponseData response_data{};
 
         response_data.section_0_size =
             response_data.state_entries.size() * sizeof(AudioRendererStateEntry);
@@ -69,9 +70,7 @@ private:
             response_data.state_entries[i].state = 5;
         }
 
-        auto& buffer = ctx.BufferDescriptorB()[0];
-
-        Memory::WriteBlock(buffer.Address(), &response_data, response_data.total_size);
+        ctx.WriteBuffer(&response_data, response_data.total_size);
 
         IPC::ResponseBuilder rb{ctx, 2};
 

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

@@ -33,12 +33,10 @@ private:
         IPC::RequestParser rp{ctx};
         const s64 offset = rp.Pop<s64>();
         const s64 length = rp.Pop<s64>();
-        const auto& descriptor = ctx.BufferDescriptorB()[0];
 
         LOG_DEBUG(Service_FS, "called, offset=0x%llx, length=0x%llx", offset, length);
 
         // Error checking
-        ASSERT_MSG(length == descriptor.Size(), "unexpected size difference");
         if (length < 0) {
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidLength));
@@ -60,7 +58,7 @@ private:
         }
 
         // Write the data to memory
-        Memory::WriteBlock(descriptor.Address(), output.data(), descriptor.Size());
+        ctx.WriteBuffer(output);
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);

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

@@ -176,7 +176,10 @@ public:
             {0, &Hid::CreateAppletResource, "CreateAppletResource"},
             {1, &Hid::ActivateDebugPad, "ActivateDebugPad"},
             {11, &Hid::ActivateTouchScreen, "ActivateTouchScreen"},
+            {21, &Hid::ActivateMouse, "ActivateMouse"},
+            {31, &Hid::ActivateKeyboard, "ActivateKeyboard"},
             {66, &Hid::StartSixAxisSensor, "StartSixAxisSensor"},
+            {79, &Hid::SetGyroscopeZeroDriftMode, "SetGyroscopeZeroDriftMode"},
             {100, &Hid::SetSupportedNpadStyleSet, "SetSupportedNpadStyleSet"},
             {102, &Hid::SetSupportedNpadIdType, "SetSupportedNpadIdType"},
             {103, &Hid::ActivateNpad, "ActivateNpad"},
@@ -184,9 +187,15 @@ public:
              "AcquireNpadStyleSetUpdateEventHandle"},
             {120, &Hid::SetNpadJoyHoldType, "SetNpadJoyHoldType"},
             {121, &Hid::GetNpadJoyHoldType, "GetNpadJoyHoldType"},
+            {122, &Hid::SetNpadJoyAssignmentModeSingleByDefault,
+             "SetNpadJoyAssignmentModeSingleByDefault"},
             {124, nullptr, "SetNpadJoyAssignmentModeDual"},
             {128, &Hid::SetNpadHandheldActivationMode, "SetNpadHandheldActivationMode"},
+            {200, &Hid::GetVibrationDeviceInfo, "GetVibrationDeviceInfo"},
+            {201, &Hid::SendVibrationValue, "SendVibrationValue"},
+            {202, &Hid::GetActualVibrationValue, "GetActualVibrationValue"},
             {203, &Hid::CreateActiveVibrationDeviceList, "CreateActiveVibrationDeviceList"},
+            {206, &Hid::SendVibrationValues, "SendVibrationValues"},
         };
         RegisterHandlers(functions);
 
@@ -222,12 +231,30 @@ private:
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
+    void ActivateMouse(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_WARNING(Service_HID, "(STUBBED) called");
+    }
+
+    void ActivateKeyboard(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        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 SetGyroscopeZeroDriftMode(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);
@@ -266,18 +293,49 @@ private:
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
+    void SetNpadJoyAssignmentModeSingleByDefault(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_WARNING(Service_HID, "(STUBBED) called");
+    }
+
+    void SendVibrationValue(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_WARNING(Service_HID, "(STUBBED) called");
+    }
+
+    void GetActualVibrationValue(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        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 GetVibrationDeviceInfo(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 4};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u64>(0);
+        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");
     }
+
+    void SendVibrationValues(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_WARNING(Service_HID, "(STUBBED) called");
+    }
 };
 
 void ReloadInputDevices() {}

src/core/hle/service/ns/ns.cpp

@@ -0,0 +1,16 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/ns/ns.h"
+#include "core/hle/service/ns/pl_u.h"
+
+namespace Service {
+namespace NS {
+
+void InstallInterfaces(SM::ServiceManager& service_manager) {
+    std::make_shared<PL_U>()->InstallAsService(service_manager);
+}
+
+} // namespace NS
+} // namespace Service

src/core/hle/service/ns/ns.h

@@ -0,0 +1,16 @@
+// 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 NS {
+
+/// Registers all NS services with the specified service manager.
+void InstallInterfaces(SM::ServiceManager& service_manager);
+
+} // namespace NS
+} // namespace Service

src/core/hle/service/ns/pl_u.cpp

@@ -0,0 +1,111 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/common_paths.h"
+#include "common/file_util.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/service/ns/pl_u.h"
+
+namespace Service {
+namespace NS {
+
+struct FontRegion {
+    u32 offset;
+    u32 size;
+};
+
+// The below data is specific to shared font data dumped from Switch on f/w 2.2
+// Virtual address and offsets/sizes likely will vary by dump
+static constexpr VAddr SHARED_FONT_MEM_VADDR{0x00000009d3016000ULL};
+static constexpr u64 SHARED_FONT_MEM_SIZE{0x1100000};
+static constexpr std::array<FontRegion, 6> SHARED_FONT_REGIONS{
+    FontRegion{0x00000008, 0x001fe764}, FontRegion{0x001fe774, 0x00773e58},
+    FontRegion{0x009725d4, 0x0001aca8}, FontRegion{0x0098d284, 0x00369cec},
+    FontRegion{0x00cf6f78, 0x0039b858}, FontRegion{0x010927d8, 0x00019e80},
+};
+
+enum class LoadState : u32 {
+    Loading = 0,
+    Done = 1,
+};
+
+PL_U::PL_U() : ServiceFramework("pl:u") {
+    static const FunctionInfo functions[] = {
+        {1, &PL_U::GetLoadState, "GetLoadState"},
+        {2, &PL_U::GetSize, "GetSize"},
+        {3, &PL_U::GetSharedMemoryAddressOffset, "GetSharedMemoryAddressOffset"},
+        {4, &PL_U::GetSharedMemoryNativeHandle, "GetSharedMemoryNativeHandle"}};
+    RegisterHandlers(functions);
+
+    // Attempt to load shared font data from disk
+    const std::string filepath{FileUtil::GetUserPath(D_SYSDATA_IDX) + SHARED_FONT};
+    FileUtil::CreateFullPath(filepath); // Create path if not already created
+    FileUtil::IOFile file(filepath, "rb");
+
+    if (file.IsOpen()) {
+        // Read shared font data
+        ASSERT(file.GetSize() == SHARED_FONT_MEM_SIZE);
+        shared_font = std::make_shared<std::vector<u8>>(static_cast<size_t>(file.GetSize()));
+        file.ReadBytes(shared_font->data(), shared_font->size());
+    } else {
+        LOG_WARNING(Service_NS, "Unable to load shared font: %s", filepath.c_str());
+    }
+}
+
+void PL_U::GetLoadState(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const u32 font_id{rp.Pop<u32>()};
+
+    LOG_DEBUG(Service_NS, "called, font_id=%d", font_id);
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push<u32>(static_cast<u32>(LoadState::Done));
+}
+
+void PL_U::GetSize(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const u32 font_id{rp.Pop<u32>()};
+
+    LOG_DEBUG(Service_NS, "called, font_id=%d", font_id);
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push<u32>(SHARED_FONT_REGIONS[font_id].size);
+}
+
+void PL_U::GetSharedMemoryAddressOffset(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const u32 font_id{rp.Pop<u32>()};
+
+    LOG_DEBUG(Service_NS, "called, font_id=%d", font_id);
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push<u32>(SHARED_FONT_REGIONS[font_id].offset);
+}
+
+void PL_U::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx) {
+    if (shared_font != nullptr) {
+        // TODO(bunnei): This is a less-than-ideal solution to load a RAM dump of the Switch shared
+        // font data. This (likely) relies on exact address, size, and offsets from the original
+        // dump. In the future, we need to replace this with a more robust solution.
+
+        // Map backing memory for the font data
+        Kernel::g_current_process->vm_manager.MapMemoryBlock(SHARED_FONT_MEM_VADDR, shared_font, 0,
+                                                             SHARED_FONT_MEM_SIZE,
+                                                             Kernel::MemoryState::Shared);
+
+        // Create shared font memory object
+        shared_font_mem = Kernel::SharedMemory::Create(
+            Kernel::g_current_process, SHARED_FONT_MEM_SIZE, Kernel::MemoryPermission::ReadWrite,
+            Kernel::MemoryPermission::Read, SHARED_FONT_MEM_VADDR, Kernel::MemoryRegion::BASE,
+            "PL_U:shared_font_mem");
+    }
+
+    LOG_DEBUG(Service_NS, "called");
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushCopyObjects(shared_font_mem);
+}
+
+} // namespace NS
+} // namespace Service

src/core/hle/service/ns/pl_u.h

@@ -0,0 +1,33 @@
+// 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/shared_memory.h"
+#include "core/hle/service/service.h"
+
+namespace Service {
+namespace NS {
+
+class PL_U final : public ServiceFramework<PL_U> {
+public:
+    PL_U();
+    ~PL_U() = default;
+
+private:
+    void GetLoadState(Kernel::HLERequestContext& ctx);
+    void GetSize(Kernel::HLERequestContext& ctx);
+    void GetSharedMemoryAddressOffset(Kernel::HLERequestContext& ctx);
+    void GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx);
+
+    /// Handle to shared memory region designated for a shared font
+    Kernel::SharedPtr<Kernel::SharedMemory> shared_font_mem;
+
+    /// Backing memory for the shared font data
+    std::shared_ptr<std::vector<u8>> shared_font;
+};
+
+} // namespace NS
+} // namespace Service

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

@@ -15,9 +15,8 @@ namespace Nvidia {
 void NVDRV::Open(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_NVDRV, "called");
 
-    auto buffer = ctx.BufferDescriptorA()[0];
-
-    std::string device_name = Memory::ReadCString(buffer.Address(), buffer.Size());
+    const auto& buffer = ctx.ReadBuffer();
+    std::string device_name(buffer.begin(), buffer.end());
 
     u32 fd = nvdrv->Open(device_name);
     IPC::ResponseBuilder rb{ctx, 4};
@@ -33,25 +32,13 @@ void NVDRV::Ioctl(Kernel::HLERequestContext& ctx) {
     u32 fd = rp.Pop<u32>();
     u32 command = rp.Pop<u32>();
 
+    std::vector<u8> output(ctx.GetWriteBufferSize());
+
     IPC::ResponseBuilder 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(nvdrv->Ioctl(fd, command, ctx.ReadBuffer(), output));
+
+    ctx.WriteBuffer(output);
 }
 
 void NVDRV::Close(Kernel::HLERequestContext& ctx) {

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

@@ -6,6 +6,7 @@
 
 #include "common/alignment.h"
 #include "common/scope_exit.h"
+#include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
@@ -129,6 +130,7 @@ void NVFlinger::Compose() {
 
         if (buffer == boost::none) {
             // There was no queued buffer to draw, render previous frame
+            Core::System::GetInstance().perf_stats.EndGameFrame();
             VideoCore::g_renderer->SwapBuffers({});
             continue;
         }

src/core/hle/service/service.cpp

@@ -23,6 +23,7 @@
 #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/ns/ns.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/pctl/pctl.h"
 #include "core/hle/service/service.h"
@@ -182,6 +183,7 @@ void Init() {
     HID::InstallInterfaces(*SM::g_service_manager);
     LM::InstallInterfaces(*SM::g_service_manager);
     NIFM::InstallInterfaces(*SM::g_service_manager);
+    NS::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

@@ -17,9 +17,7 @@ void SET::GetAvailableLanguageCodes(Kernel::HLERequestContext& 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());
+    ctx.WriteBuffer(lang_codes.data(), lang_codes.size());
 
     IPC::ResponseBuilder rb{ctx, 2};
 

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

@@ -429,7 +429,7 @@ public:
             {0, &IHOSBinderDriver::TransactParcel, "TransactParcel"},
             {1, &IHOSBinderDriver::AdjustRefcount, "AdjustRefcount"},
             {2, &IHOSBinderDriver::GetNativeHandle, "GetNativeHandle"},
-            {3, &IHOSBinderDriver::TransactParcelAuto, "TransactParcelAuto"},
+            {3, &IHOSBinderDriver::TransactParcel, "TransactParcelAuto"},
         };
         RegisterHandlers(functions);
     }
@@ -453,95 +453,61 @@ private:
         SetPreallocatedBuffer = 14
     };
 
-    void TransactParcel(u32 id, TransactionId transaction, const std::vector<u8>& input_data,
-                        VAddr output_addr, u64 output_size) {
-        auto buffer_queue = nv_flinger->GetBufferQueue(id);
-
-        if (transaction == TransactionId::Connect) {
-            IGBPConnectRequestParcel request{input_data};
-            IGBPConnectResponseParcel response{1280, 720};
-            std::vector<u8> response_buffer = response.Serialize();
-            Memory::WriteBlock(output_addr, response_buffer.data(), response_buffer.size());
-        } else if (transaction == TransactionId::SetPreallocatedBuffer) {
-            IGBPSetPreallocatedBufferRequestParcel request{input_data};
-
-            buffer_queue->SetPreallocatedBuffer(request.data.slot, request.buffer);
-
-            IGBPSetPreallocatedBufferResponseParcel response{};
-            std::vector<u8> response_buffer = response.Serialize();
-            Memory::WriteBlock(output_addr, response_buffer.data(), response_buffer.size());
-        } else if (transaction == TransactionId::DequeueBuffer) {
-            IGBPDequeueBufferRequestParcel request{input_data};
-
-            u32 slot = buffer_queue->DequeueBuffer(request.data.pixel_format, request.data.width,
-                                                   request.data.height);
-
-            IGBPDequeueBufferResponseParcel response{slot};
-            std::vector<u8> response_buffer = response.Serialize();
-            Memory::WriteBlock(output_addr, response_buffer.data(), response_buffer.size());
-        } else if (transaction == TransactionId::RequestBuffer) {
-            IGBPRequestBufferRequestParcel request{input_data};
-
-            auto& buffer = buffer_queue->RequestBuffer(request.slot);
-
-            IGBPRequestBufferResponseParcel response{buffer};
-            std::vector<u8> response_buffer = response.Serialize();
-            Memory::WriteBlock(output_addr, response_buffer.data(), response_buffer.size());
-        } else if (transaction == TransactionId::QueueBuffer) {
-            IGBPQueueBufferRequestParcel request{input_data};
-
-            buffer_queue->QueueBuffer(request.data.slot, request.data.transform);
-
-            IGBPQueueBufferResponseParcel response{1280, 720};
-            std::vector<u8> response_buffer = response.Serialize();
-            Memory::WriteBlock(output_addr, response_buffer.data(), response_buffer.size());
-        } else if (transaction == TransactionId::Query) {
-            IGBPQueryRequestParcel request{input_data};
-
-            u32 value =
-                buffer_queue->Query(static_cast<NVFlinger::BufferQueue::QueryType>(request.type));
-
-            IGBPQueryResponseParcel response{value};
-            std::vector<u8> response_buffer = response.Serialize();
-            Memory::WriteBlock(output_addr, response_buffer.data(), response_buffer.size());
-        } else if (transaction == TransactionId::CancelBuffer) {
-            LOG_WARNING(Service_VI, "(STUBBED) called, transaction=CancelBuffer");
-        } else {
-            ASSERT_MSG(false, "Unimplemented");
-        }
-    }
-
     void TransactParcel(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         u32 id = rp.Pop<u32>();
         auto transaction = static_cast<TransactionId>(rp.Pop<u32>());
         u32 flags = rp.Pop<u32>();
+        auto buffer_queue = nv_flinger->GetBufferQueue(id);
+
         LOG_DEBUG(Service_VI, "called, transaction=%x", transaction);
 
-        auto& input_buffer = ctx.BufferDescriptorA()[0];
-        auto& output_buffer = ctx.BufferDescriptorB()[0];
-        std::vector<u8> input_data(input_buffer.Size());
-        Memory::ReadBlock(input_buffer.Address(), input_data.data(), input_buffer.Size());
+        if (transaction == TransactionId::Connect) {
+            IGBPConnectRequestParcel request{ctx.ReadBuffer()};
+            IGBPConnectResponseParcel response{1280, 720};
+            ctx.WriteBuffer(response.Serialize());
+        } else if (transaction == TransactionId::SetPreallocatedBuffer) {
+            IGBPSetPreallocatedBufferRequestParcel request{ctx.ReadBuffer()};
 
-        TransactParcel(id, transaction, input_data, output_buffer.Address(), output_buffer.Size());
+            buffer_queue->SetPreallocatedBuffer(request.data.slot, request.buffer);
 
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
+            IGBPSetPreallocatedBufferResponseParcel response{};
+            ctx.WriteBuffer(response.Serialize());
+        } else if (transaction == TransactionId::DequeueBuffer) {
+            IGBPDequeueBufferRequestParcel request{ctx.ReadBuffer()};
 
-    void TransactParcelAuto(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        u32 id = rp.Pop<u32>();
-        auto transaction = static_cast<TransactionId>(rp.Pop<u32>());
-        u32 flags = rp.Pop<u32>();
-        LOG_DEBUG(Service_VI, "called, transaction=%x", transaction);
+            u32 slot = buffer_queue->DequeueBuffer(request.data.pixel_format, request.data.width,
+                                                   request.data.height);
 
-        auto& input_buffer = ctx.BufferDescriptorX()[0];
-        auto& output_buffer = ctx.BufferDescriptorC()[0];
-        std::vector<u8> input_data(input_buffer.size);
-        Memory::ReadBlock(input_buffer.Address(), input_data.data(), input_buffer.size);
+            IGBPDequeueBufferResponseParcel response{slot};
+            ctx.WriteBuffer(response.Serialize());
+        } else if (transaction == TransactionId::RequestBuffer) {
+            IGBPRequestBufferRequestParcel request{ctx.ReadBuffer()};
 
-        TransactParcel(id, transaction, input_data, output_buffer.Address(), output_buffer.Size());
+            auto& buffer = buffer_queue->RequestBuffer(request.slot);
+
+            IGBPRequestBufferResponseParcel response{buffer};
+            ctx.WriteBuffer(response.Serialize());
+        } else if (transaction == TransactionId::QueueBuffer) {
+            IGBPQueueBufferRequestParcel request{ctx.ReadBuffer()};
+
+            buffer_queue->QueueBuffer(request.data.slot, request.data.transform);
+
+            IGBPQueueBufferResponseParcel response{1280, 720};
+            ctx.WriteBuffer(response.Serialize());
+        } else if (transaction == TransactionId::Query) {
+            IGBPQueryRequestParcel request{ctx.ReadBuffer()};
+
+            u32 value =
+                buffer_queue->Query(static_cast<NVFlinger::BufferQueue::QueryType>(request.type));
+
+            IGBPQueryResponseParcel response{value};
+            ctx.WriteBuffer(response.Serialize());
+        } else if (transaction == TransactionId::CancelBuffer) {
+            LOG_WARNING(Service_VI, "(STUBBED) called, transaction=CancelBuffer");
+        } else {
+            ASSERT_MSG(false, "Unimplemented");
+        }
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -719,18 +685,13 @@ void IApplicationDisplayService::OpenLayer(Kernel::HLERequestContext& ctx) {
     u64 layer_id = rp.Pop<u64>();
     u64 aruid = rp.Pop<u64>();
 
-    auto& buffer = ctx.BufferDescriptorB()[0];
-
     u64 display_id = nv_flinger->OpenDisplay(display_name);
     u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id);
 
     NativeWindow native_window{buffer_queue_id};
-    auto data = native_window.Serialize();
-    Memory::WriteBlock(buffer.Address(), data.data(), data.size());
-
     IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(data.size());
+    rb.Push<u64>(ctx.WriteBuffer(native_window.Serialize()));
 }
 
 void IApplicationDisplayService::CreateStrayLayer(Kernel::HLERequestContext& ctx) {
@@ -741,21 +702,16 @@ void IApplicationDisplayService::CreateStrayLayer(Kernel::HLERequestContext& ctx
     rp.Pop<u32>(); // padding
     u64 display_id = rp.Pop<u64>();
 
-    auto& buffer = ctx.BufferDescriptorB()[0];
-
     // TODO(Subv): What's the difference between a Stray and a Managed layer?
 
     u64 layer_id = nv_flinger->CreateLayer(display_id);
     u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id);
 
     NativeWindow native_window{buffer_queue_id};
-    auto data = native_window.Serialize();
-    Memory::WriteBlock(buffer.Address(), data.data(), data.size());
-
     IPC::ResponseBuilder rb = rp.MakeBuilder(6, 0, 0);
     rb.Push(RESULT_SUCCESS);
     rb.Push(layer_id);
-    rb.Push<u64>(data.size());
+    rb.Push<u64>(ctx.WriteBuffer(native_window.Serialize()));
 }
 
 void IApplicationDisplayService::DestroyStrayLayer(Kernel::HLERequestContext& ctx) {
@@ -781,8 +737,7 @@ void IApplicationDisplayService::SetLayerScalingMode(Kernel::HLERequestContext&
 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));
+    ctx.WriteBuffer(&display_info, sizeof(DisplayInfo));
     IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
     rb.Push(RESULT_SUCCESS);
     rb.Push<u64>(1);