5 files changed, 71 insertions, 18 deletions

diff --git a/src/core/hle/kernel/hle_ipc.cpp b/src/core/hle/kernel/hle_ipc.cpp
index 45135a07f..5b3feec66 100644
--- a/src/core/hle/kernel/hle_ipc.cpp
+++ b/src/core/hle/kernel/hle_ipc.cpp
@@ -287,18 +287,52 @@ std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,
             BufferDescriptorB().size() > buffer_index &&
                 BufferDescriptorB()[buffer_index].Size() >= size,
             { return 0; }, "BufferDescriptorB is invalid, index={}, size={}", buffer_index, size);
-        memory.WriteBlock(BufferDescriptorB()[buffer_index].Address(), buffer, size);
+        WriteBufferB(buffer, size, buffer_index);
     } else {
         ASSERT_OR_EXECUTE_MSG(
             BufferDescriptorC().size() > buffer_index &&
                 BufferDescriptorC()[buffer_index].Size() >= size,
             { return 0; }, "BufferDescriptorC is invalid, index={}, size={}", buffer_index, size);
-        memory.WriteBlock(BufferDescriptorC()[buffer_index].Address(), buffer, size);
+        WriteBufferC(buffer, size, buffer_index);
     }
 
     return size;
 }
 
+std::size_t HLERequestContext::WriteBufferB(const void* buffer, std::size_t size,
+                                            std::size_t buffer_index) const {
+    if (buffer_index >= BufferDescriptorB().size() || size == 0) {
+        return 0;
+    }
+
+    const auto buffer_size{BufferDescriptorB()[buffer_index].Size()};
+    if (size > buffer_size) {
+        LOG_CRITICAL(Core, "size ({:016X}) is greater than buffer_size ({:016X})", size,
+                     buffer_size);
+        size = buffer_size; // TODO(bunnei): This needs to be HW tested
+    }
+
+    memory.WriteBlock(BufferDescriptorB()[buffer_index].Address(), buffer, size);
+    return size;
+}
+
+std::size_t HLERequestContext::WriteBufferC(const void* buffer, std::size_t size,
+                                            std::size_t buffer_index) const {
+    if (buffer_index >= BufferDescriptorC().size() || size == 0) {
+        return 0;
+    }
+
+    const auto buffer_size{BufferDescriptorC()[buffer_index].Size()};
+    if (size > buffer_size) {
+        LOG_CRITICAL(Core, "size ({:016X}) is greater than buffer_size ({:016X})", size,
+                     buffer_size);
+        size = buffer_size; // TODO(bunnei): This needs to be HW tested
+    }
+
+    memory.WriteBlock(BufferDescriptorC()[buffer_index].Address(), buffer, size);
+    return size;
+}
+
 std::size_t HLERequestContext::GetReadBufferSize(std::size_t buffer_index) const {
     const bool is_buffer_a{BufferDescriptorA().size() > buffer_index &&
                            BufferDescriptorA()[buffer_index].Size()};
diff --git a/src/core/hle/kernel/hle_ipc.h b/src/core/hle/kernel/hle_ipc.h
index d3abeee85..99265ce90 100644
--- a/src/core/hle/kernel/hle_ipc.h
+++ b/src/core/hle/kernel/hle_ipc.h
@@ -277,6 +277,14 @@ public:
     std::size_t WriteBuffer(const void* buffer, std::size_t size,
                             std::size_t buffer_index = 0) const;
 
+    /// Helper function to write buffer B
+    std::size_t WriteBufferB(const void* buffer, std::size_t size,
+                             std::size_t buffer_index = 0) const;
+
+    /// Helper function to write buffer C
+    std::size_t WriteBufferC(const void* buffer, std::size_t size,
+                             std::size_t buffer_index = 0) const;
+
     /* Helper function to write a buffer using the appropriate buffer descriptor
      *
      * @tparam T an arbitrary container that satisfies the
diff --git a/src/core/hle/kernel/k_code_memory.h b/src/core/hle/kernel/k_code_memory.h
index 2410f74a3..2e7e1436a 100644
--- a/src/core/hle/kernel/k_code_memory.h
+++ b/src/core/hle/kernel/k_code_memory.h
@@ -30,19 +30,19 @@ public:
     explicit KCodeMemory(KernelCore& kernel_);
 
     Result Initialize(Core::DeviceMemory& device_memory, VAddr address, size_t size);
-    void Finalize();
+    void Finalize() override;
 
     Result Map(VAddr address, size_t size);
     Result Unmap(VAddr address, size_t size);
     Result MapToOwner(VAddr address, size_t size, Svc::MemoryPermission perm);
     Result UnmapFromOwner(VAddr address, size_t size);
 
-    bool IsInitialized() const {
+    bool IsInitialized() const override {
         return m_is_initialized;
     }
     static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
 
-    KProcess* GetOwner() const {
+    KProcess* GetOwner() const override {
         return m_owner;
     }
     VAddr GetSourceAddress() const {
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index 926c6dc84..f4072e1c3 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -93,19 +93,7 @@ struct KernelCore::Impl {
 
         process_list.clear();
 
-        // Close all open server sessions and ports.
-        std::unordered_set<KAutoObject*> server_objects_;
-        {
-            std::scoped_lock lk(server_objects_lock);
-            server_objects_ = server_objects;
-            server_objects.clear();
-        }
-        for (auto* server_object : server_objects_) {
-            server_object->Close();
-        }
-
-        // Ensures all service threads gracefully shutdown.
-        ClearServiceThreads();
+        CloseServices();
 
         next_object_id = 0;
         next_kernel_process_id = KProcess::InitialKIPIDMin;
@@ -188,6 +176,22 @@ struct KernelCore::Impl {
         global_object_list_container.reset();
     }
 
+    void CloseServices() {
+        // Close all open server sessions and ports.
+        std::unordered_set<KAutoObject*> server_objects_;
+        {
+            std::scoped_lock lk(server_objects_lock);
+            server_objects_ = server_objects;
+            server_objects.clear();
+        }
+        for (auto* server_object : server_objects_) {
+            server_object->Close();
+        }
+
+        // Ensures all service threads gracefully shutdown.
+        ClearServiceThreads();
+    }
+
     void InitializePhysicalCores() {
         exclusive_monitor =
             Core::MakeExclusiveMonitor(system.Memory(), Core::Hardware::NUM_CPU_CORES);
@@ -817,6 +821,10 @@ void KernelCore::Shutdown() {
     impl->Shutdown();
 }
 
+void KernelCore::CloseServices() {
+    impl->CloseServices();
+}
+
 const KResourceLimit* KernelCore::GetSystemResourceLimit() const {
     return impl->system_resource_limit;
 }
diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h
index aa0ebaa02..6c7cf6af2 100644
--- a/src/core/hle/kernel/kernel.h
+++ b/src/core/hle/kernel/kernel.h
@@ -109,6 +109,9 @@ public:
     /// Clears all resources in use by the kernel instance.
     void Shutdown();
 
+    /// Close all active services in use by the kernel instance.
+    void CloseServices();
+
     /// Retrieves a shared pointer to the system resource limit instance.
     const KResourceLimit* GetSystemResourceLimit() const;