From 380475af32507cf8fd1a42d470667bce8f0b69c7 Mon Sep 17 00:00:00 2001
From: FearlessTobi <thm.frey@gmail.com>
Date: Sun, 18 Feb 2024 23:02:37 +0100
Subject: fsp: Move ISaveDataInfoReader to a seperate file

---
 .../filesystem/fsp/fs_i_save_data_info_reader.cpp  | 162 ++++++++++++++++++++
 .../filesystem/fsp/fs_i_save_data_info_reader.h    |  48 ++++++
 src/core/hle/service/filesystem/fsp/fsp_srv.cpp    | 167 +--------------------
 3 files changed, 212 insertions(+), 165 deletions(-)
 create mode 100644 src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp
 create mode 100644 src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h

(limited to 'src/core/hle/service/filesystem/fsp')

diff --git a/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp b/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp
new file mode 100644
index 000000000..872377d03
--- /dev/null
+++ b/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp
@@ -0,0 +1,162 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/hex_util.h"
+#include "core/file_sys/savedata_factory.h"
+#include "core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h"
+#include "core/hle/service/filesystem/save_data_controller.h"
+#include "core/hle/service/ipc_helpers.h"
+
+namespace Service::FileSystem {
+
+ISaveDataInfoReader::ISaveDataInfoReader(Core::System& system_,
+                                         std::shared_ptr<SaveDataController> save_data_controller_,
+                                         FileSys::SaveDataSpaceId space)
+    : ServiceFramework{system_, "ISaveDataInfoReader"},
+      save_data_controller{save_data_controller_} {
+    static const FunctionInfo functions[] = {
+        {0, &ISaveDataInfoReader::ReadSaveDataInfo, "ReadSaveDataInfo"},
+    };
+    RegisterHandlers(functions);
+
+    FindAllSaves(space);
+}
+
+ISaveDataInfoReader::~ISaveDataInfoReader() = default;
+
+static u64 stoull_be(std::string_view str) {
+    if (str.size() != 16) {
+        return 0;
+    }
+
+    const auto bytes = Common::HexStringToArray<0x8>(str);
+    u64 out{};
+    std::memcpy(&out, bytes.data(), sizeof(u64));
+
+    return Common::swap64(out);
+}
+
+void ISaveDataInfoReader::ReadSaveDataInfo(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_FS, "called");
+
+    // Calculate how many entries we can fit in the output buffer
+    const u64 count_entries = ctx.GetWriteBufferNumElements<SaveDataInfo>();
+
+    // Cap at total number of entries.
+    const u64 actual_entries = std::min(count_entries, info.size() - next_entry_index);
+
+    // Determine data start and end
+    const auto* begin = reinterpret_cast<u8*>(info.data() + next_entry_index);
+    const auto* end = reinterpret_cast<u8*>(info.data() + next_entry_index + actual_entries);
+    const auto range_size = static_cast<std::size_t>(std::distance(begin, end));
+
+    next_entry_index += actual_entries;
+
+    // Write the data to memory
+    ctx.WriteBuffer(begin, range_size);
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(ResultSuccess);
+    rb.Push<u64>(actual_entries);
+}
+
+void ISaveDataInfoReader::FindAllSaves(FileSys::SaveDataSpaceId space) {
+    FileSys::VirtualDir save_root{};
+    const auto result = save_data_controller->OpenSaveDataSpace(&save_root, space);
+
+    if (result != ResultSuccess || save_root == nullptr) {
+        LOG_ERROR(Service_FS, "The save root for the space_id={:02X} was invalid!", space);
+        return;
+    }
+
+    for (const auto& type : save_root->GetSubdirectories()) {
+        if (type->GetName() == "save") {
+            FindNormalSaves(space, type);
+        } else if (space == FileSys::SaveDataSpaceId::TemporaryStorage) {
+            FindTemporaryStorageSaves(space, type);
+        }
+    }
+}
+
+void ISaveDataInfoReader::FindNormalSaves(FileSys::SaveDataSpaceId space,
+                                          const FileSys::VirtualDir& type) {
+    for (const auto& save_id : type->GetSubdirectories()) {
+        for (const auto& user_id : save_id->GetSubdirectories()) {
+            // Skip non user id subdirectories
+            if (user_id->GetName().size() != 0x20) {
+                continue;
+            }
+
+            const auto save_id_numeric = stoull_be(save_id->GetName());
+            auto user_id_numeric = Common::HexStringToArray<0x10>(user_id->GetName());
+            std::reverse(user_id_numeric.begin(), user_id_numeric.end());
+
+            if (save_id_numeric != 0) {
+                // System Save Data
+                info.emplace_back(SaveDataInfo{
+                    0,
+                    space,
+                    FileSys::SaveDataType::SystemSaveData,
+                    {},
+                    user_id_numeric,
+                    save_id_numeric,
+                    0,
+                    user_id->GetSize(),
+                    {},
+                    {},
+                });
+
+                continue;
+            }
+
+            for (const auto& title_id : user_id->GetSubdirectories()) {
+                const auto device = std::all_of(user_id_numeric.begin(), user_id_numeric.end(),
+                                                [](u8 val) { return val == 0; });
+                info.emplace_back(SaveDataInfo{
+                    0,
+                    space,
+                    device ? FileSys::SaveDataType::DeviceSaveData
+                           : FileSys::SaveDataType::SaveData,
+                    {},
+                    user_id_numeric,
+                    save_id_numeric,
+                    stoull_be(title_id->GetName()),
+                    title_id->GetSize(),
+                    {},
+                    {},
+                });
+            }
+        }
+    }
+}
+
+void ISaveDataInfoReader::FindTemporaryStorageSaves(FileSys::SaveDataSpaceId space,
+                                                    const FileSys::VirtualDir& type) {
+    for (const auto& user_id : type->GetSubdirectories()) {
+        // Skip non user id subdirectories
+        if (user_id->GetName().size() != 0x20) {
+            continue;
+        }
+        for (const auto& title_id : user_id->GetSubdirectories()) {
+            if (!title_id->GetFiles().empty() || !title_id->GetSubdirectories().empty()) {
+                auto user_id_numeric = Common::HexStringToArray<0x10>(user_id->GetName());
+                std::reverse(user_id_numeric.begin(), user_id_numeric.end());
+
+                info.emplace_back(SaveDataInfo{
+                    0,
+                    space,
+                    FileSys::SaveDataType::TemporaryStorage,
+                    {},
+                    user_id_numeric,
+                    stoull_be(type->GetName()),
+                    stoull_be(title_id->GetName()),
+                    title_id->GetSize(),
+                    {},
+                    {},
+                });
+            }
+        }
+    }
+}
+
+} // namespace Service::FileSystem
diff --git a/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h b/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h
new file mode 100644
index 000000000..86e09973b
--- /dev/null
+++ b/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h
@@ -0,0 +1,48 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <vector>
+#include "common/common_types.h"
+#include "core/hle/service/service.h"
+
+namespace Service::FileSystem {
+
+class SaveDataController;
+
+class ISaveDataInfoReader final : public ServiceFramework<ISaveDataInfoReader> {
+public:
+    explicit ISaveDataInfoReader(Core::System& system_,
+                                 std::shared_ptr<SaveDataController> save_data_controller_,
+                                 FileSys::SaveDataSpaceId space);
+    ~ISaveDataInfoReader() override;
+
+    void ReadSaveDataInfo(HLERequestContext& ctx);
+
+private:
+    void FindAllSaves(FileSys::SaveDataSpaceId space);
+    void FindNormalSaves(FileSys::SaveDataSpaceId space, const FileSys::VirtualDir& type);
+    void FindTemporaryStorageSaves(FileSys::SaveDataSpaceId space, const FileSys::VirtualDir& type);
+
+    struct SaveDataInfo {
+        u64_le save_id_unknown;
+        FileSys::SaveDataSpaceId space;
+        FileSys::SaveDataType type;
+        INSERT_PADDING_BYTES_NOINIT(0x6);
+        std::array<u8, 0x10> user_id;
+        u64_le save_id;
+        u64_le title_id;
+        u64_le save_image_size;
+        u16_le index;
+        FileSys::SaveDataRank rank;
+        INSERT_PADDING_BYTES_NOINIT(0x25);
+    };
+    static_assert(sizeof(SaveDataInfo) == 0x60, "SaveDataInfo has incorrect size.");
+
+    std::shared_ptr<SaveDataController> save_data_controller;
+    std::vector<SaveDataInfo> info;
+    u64 next_entry_index = 0;
+};
+
+} // namespace Service::FileSystem
diff --git a/src/core/hle/service/filesystem/fsp/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp/fsp_srv.cpp
index 2d49f30c8..8664ead29 100644
--- a/src/core/hle/service/filesystem/fsp/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp/fsp_srv.cpp
@@ -29,6 +29,7 @@
 #include "core/hle/result.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/filesystem/fsp/fs_i_filesystem.h"
+#include "core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h"
 #include "core/hle/service/filesystem/fsp/fs_i_storage.h"
 #include "core/hle/service/filesystem/fsp/fsp_srv.h"
 #include "core/hle/service/filesystem/romfs_controller.h"
@@ -39,6 +40,7 @@
 #include "core/reporter.h"
 
 namespace Service::FileSystem {
+
 enum class FileSystemProxyType : u8 {
     Code = 0,
     Rom = 1,
@@ -51,171 +53,6 @@ enum class FileSystemProxyType : u8 {
     RegisteredUpdate = 8,
 };
 
-class ISaveDataInfoReader final : public ServiceFramework<ISaveDataInfoReader> {
-public:
-    explicit ISaveDataInfoReader(Core::System& system_,
-                                 std::shared_ptr<SaveDataController> save_data_controller_,
-                                 FileSys::SaveDataSpaceId space)
-        : ServiceFramework{system_, "ISaveDataInfoReader"}, save_data_controller{
-                                                                save_data_controller_} {
-        static const FunctionInfo functions[] = {
-            {0, &ISaveDataInfoReader::ReadSaveDataInfo, "ReadSaveDataInfo"},
-        };
-        RegisterHandlers(functions);
-
-        FindAllSaves(space);
-    }
-
-    void ReadSaveDataInfo(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_FS, "called");
-
-        // Calculate how many entries we can fit in the output buffer
-        const u64 count_entries = ctx.GetWriteBufferNumElements<SaveDataInfo>();
-
-        // Cap at total number of entries.
-        const u64 actual_entries = std::min(count_entries, info.size() - next_entry_index);
-
-        // Determine data start and end
-        const auto* begin = reinterpret_cast<u8*>(info.data() + next_entry_index);
-        const auto* end = reinterpret_cast<u8*>(info.data() + next_entry_index + actual_entries);
-        const auto range_size = static_cast<std::size_t>(std::distance(begin, end));
-
-        next_entry_index += actual_entries;
-
-        // Write the data to memory
-        ctx.WriteBuffer(begin, range_size);
-
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(ResultSuccess);
-        rb.Push<u64>(actual_entries);
-    }
-
-private:
-    static u64 stoull_be(std::string_view str) {
-        if (str.size() != 16)
-            return 0;
-
-        const auto bytes = Common::HexStringToArray<0x8>(str);
-        u64 out{};
-        std::memcpy(&out, bytes.data(), sizeof(u64));
-
-        return Common::swap64(out);
-    }
-
-    void FindAllSaves(FileSys::SaveDataSpaceId space) {
-        FileSys::VirtualDir save_root{};
-        const auto result = save_data_controller->OpenSaveDataSpace(&save_root, space);
-
-        if (result != ResultSuccess || save_root == nullptr) {
-            LOG_ERROR(Service_FS, "The save root for the space_id={:02X} was invalid!", space);
-            return;
-        }
-
-        for (const auto& type : save_root->GetSubdirectories()) {
-            if (type->GetName() == "save") {
-                for (const auto& save_id : type->GetSubdirectories()) {
-                    for (const auto& user_id : save_id->GetSubdirectories()) {
-                        // Skip non user id subdirectories
-                        if (user_id->GetName().size() != 0x20) {
-                            continue;
-                        }
-
-                        const auto save_id_numeric = stoull_be(save_id->GetName());
-                        auto user_id_numeric = Common::HexStringToArray<0x10>(user_id->GetName());
-                        std::reverse(user_id_numeric.begin(), user_id_numeric.end());
-
-                        if (save_id_numeric != 0) {
-                            // System Save Data
-                            info.emplace_back(SaveDataInfo{
-                                0,
-                                space,
-                                FileSys::SaveDataType::SystemSaveData,
-                                {},
-                                user_id_numeric,
-                                save_id_numeric,
-                                0,
-                                user_id->GetSize(),
-                                {},
-                                {},
-                            });
-
-                            continue;
-                        }
-
-                        for (const auto& title_id : user_id->GetSubdirectories()) {
-                            const auto device =
-                                std::all_of(user_id_numeric.begin(), user_id_numeric.end(),
-                                            [](u8 val) { return val == 0; });
-                            info.emplace_back(SaveDataInfo{
-                                0,
-                                space,
-                                device ? FileSys::SaveDataType::DeviceSaveData
-                                       : FileSys::SaveDataType::SaveData,
-                                {},
-                                user_id_numeric,
-                                save_id_numeric,
-                                stoull_be(title_id->GetName()),
-                                title_id->GetSize(),
-                                {},
-                                {},
-                            });
-                        }
-                    }
-                }
-            } else if (space == FileSys::SaveDataSpaceId::TemporaryStorage) {
-                // Temporary Storage
-                for (const auto& user_id : type->GetSubdirectories()) {
-                    // Skip non user id subdirectories
-                    if (user_id->GetName().size() != 0x20) {
-                        continue;
-                    }
-                    for (const auto& title_id : user_id->GetSubdirectories()) {
-                        if (!title_id->GetFiles().empty() ||
-                            !title_id->GetSubdirectories().empty()) {
-                            auto user_id_numeric =
-                                Common::HexStringToArray<0x10>(user_id->GetName());
-                            std::reverse(user_id_numeric.begin(), user_id_numeric.end());
-
-                            info.emplace_back(SaveDataInfo{
-                                0,
-                                space,
-                                FileSys::SaveDataType::TemporaryStorage,
-                                {},
-                                user_id_numeric,
-                                stoull_be(type->GetName()),
-                                stoull_be(title_id->GetName()),
-                                title_id->GetSize(),
-                                {},
-                                {},
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    struct SaveDataInfo {
-        u64_le save_id_unknown;
-        FileSys::SaveDataSpaceId space;
-        FileSys::SaveDataType type;
-        INSERT_PADDING_BYTES(0x6);
-        std::array<u8, 0x10> user_id;
-        u64_le save_id;
-        u64_le title_id;
-        u64_le save_image_size;
-        u16_le index;
-        FileSys::SaveDataRank rank;
-        INSERT_PADDING_BYTES(0x25);
-    };
-    static_assert(sizeof(SaveDataInfo) == 0x60, "SaveDataInfo has incorrect size.");
-
-    ProcessId process_id = 0;
-    std::shared_ptr<SaveDataController> save_data_controller;
-    std::vector<SaveDataInfo> info;
-    u64 next_entry_index = 0;
-};
-
 FSP_SRV::FSP_SRV(Core::System& system_)
     : ServiceFramework{system_, "fsp-srv"}, fsc{system.GetFileSystemController()},
       content_provider{system.GetContentProvider()}, reporter{system.GetReporter()} {
-- 
cgit v1.2.3


From b7d9eba72b504039548c5bb1fb64cfec9f3011cb Mon Sep 17 00:00:00 2001
From: FearlessTobi <thm.frey@gmail.com>
Date: Sun, 18 Feb 2024 23:26:18 +0100
Subject: fsp: Move IMultiCommitManager to a seperate file

---
 .../filesystem/fsp/fs_i_multi_commit_manager.cpp   | 34 ++++++++++++++++++++++
 .../filesystem/fsp/fs_i_multi_commit_manager.h     | 23 +++++++++++++++
 src/core/hle/service/filesystem/fsp/fsp_srv.cpp    | 30 +------------------
 3 files changed, 58 insertions(+), 29 deletions(-)
 create mode 100644 src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.cpp
 create mode 100644 src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h

(limited to 'src/core/hle/service/filesystem/fsp')

diff --git a/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.cpp b/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.cpp
new file mode 100644
index 000000000..054bf5054
--- /dev/null
+++ b/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.cpp
@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h"
+#include "core/hle/service/ipc_helpers.h"
+
+namespace Service::FileSystem {
+
+IMultiCommitManager::IMultiCommitManager(Core::System& system_)
+    : ServiceFramework{system_, "IMultiCommitManager"} {
+    static const FunctionInfo functions[] = {
+        {1, &IMultiCommitManager::Add, "Add"},
+        {2, &IMultiCommitManager::Commit, "Commit"},
+    };
+    RegisterHandlers(functions);
+}
+
+IMultiCommitManager::~IMultiCommitManager() = default;
+
+void IMultiCommitManager::Add(HLERequestContext& ctx) {
+    LOG_WARNING(Service_FS, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void IMultiCommitManager::Commit(HLERequestContext& ctx) {
+    LOG_WARNING(Service_FS, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+} // namespace Service::FileSystem
diff --git a/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h b/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h
new file mode 100644
index 000000000..6124873b3
--- /dev/null
+++ b/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h
@@ -0,0 +1,23 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/file_sys/vfs/vfs.h"
+#include "core/hle/service/service.h"
+
+namespace Service::FileSystem {
+
+class IMultiCommitManager final : public ServiceFramework<IMultiCommitManager> {
+public:
+    explicit IMultiCommitManager(Core::System& system_);
+    ~IMultiCommitManager() override;
+
+private:
+    void Add(HLERequestContext& ctx);
+    void Commit(HLERequestContext& ctx);
+
+    FileSys::VirtualFile backend;
+};
+
+} // namespace Service::FileSystem
diff --git a/src/core/hle/service/filesystem/fsp/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp/fsp_srv.cpp
index 8664ead29..228e6269e 100644
--- a/src/core/hle/service/filesystem/fsp/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp/fsp_srv.cpp
@@ -28,6 +28,7 @@
 #include "core/file_sys/vfs/vfs.h"
 #include "core/hle/result.h"
 #include "core/hle/service/filesystem/filesystem.h"
+#include "core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h"
 #include "core/hle/service/filesystem/fsp/fs_i_filesystem.h"
 #include "core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h"
 #include "core/hle/service/filesystem/fsp/fs_i_storage.h"
@@ -562,35 +563,6 @@ void FSP_SRV::GetCacheStorageSize(HLERequestContext& ctx) {
     rb.Push(s64{0});
 }
 
-class IMultiCommitManager final : public ServiceFramework<IMultiCommitManager> {
-public:
-    explicit IMultiCommitManager(Core::System& system_)
-        : ServiceFramework{system_, "IMultiCommitManager"} {
-        static const FunctionInfo functions[] = {
-            {1, &IMultiCommitManager::Add, "Add"},
-            {2, &IMultiCommitManager::Commit, "Commit"},
-        };
-        RegisterHandlers(functions);
-    }
-
-private:
-    FileSys::VirtualFile backend;
-
-    void Add(HLERequestContext& ctx) {
-        LOG_WARNING(Service_FS, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void Commit(HLERequestContext& ctx) {
-        LOG_WARNING(Service_FS, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-};
-
 void FSP_SRV::OpenMultiCommitManager(HLERequestContext& ctx) {
     LOG_DEBUG(Service_FS, "called");
 
-- 
cgit v1.2.3


From fdf4a5bc90ac9b5812fbaefa4c5451cf6824301a Mon Sep 17 00:00:00 2001
From: FearlessTobi <thm.frey@gmail.com>
Date: Mon, 19 Feb 2024 02:17:16 +0100
Subject: fsp-srv: Migrate to use cmif serialization

---
 src/core/hle/service/filesystem/fsp/fsp_srv.cpp | 384 +++++++++---------------
 src/core/hle/service/filesystem/fsp/fsp_srv.h   |  82 +++--
 2 files changed, 203 insertions(+), 263 deletions(-)

(limited to 'src/core/hle/service/filesystem/fsp')

diff --git a/src/core/hle/service/filesystem/fsp/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp/fsp_srv.cpp
index 228e6269e..2f3b01595 100644
--- a/src/core/hle/service/filesystem/fsp/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp/fsp_srv.cpp
@@ -27,9 +27,10 @@
 #include "core/file_sys/system_archive/system_archive.h"
 #include "core/file_sys/vfs/vfs.h"
 #include "core/hle/result.h"
+#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/filesystem/filesystem.h"
-#include "core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h"
 #include "core/hle/service/filesystem/fsp/fs_i_filesystem.h"
+#include "core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h"
 #include "core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h"
 #include "core/hle/service/filesystem/fsp/fs_i_storage.h"
 #include "core/hle/service/filesystem/fsp/fsp_srv.h"
@@ -42,38 +43,26 @@
 
 namespace Service::FileSystem {
 
-enum class FileSystemProxyType : u8 {
-    Code = 0,
-    Rom = 1,
-    Logo = 2,
-    Control = 3,
-    Manual = 4,
-    Meta = 5,
-    Data = 6,
-    Package = 7,
-    RegisteredUpdate = 8,
-};
-
 FSP_SRV::FSP_SRV(Core::System& system_)
     : ServiceFramework{system_, "fsp-srv"}, fsc{system.GetFileSystemController()},
       content_provider{system.GetContentProvider()}, reporter{system.GetReporter()} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "OpenFileSystem"},
-        {1, &FSP_SRV::SetCurrentProcess, "SetCurrentProcess"},
+        {1, D<&FSP_SRV::SetCurrentProcess>, "SetCurrentProcess"},
         {2, nullptr, "OpenDataFileSystemByCurrentProcess"},
-        {7, &FSP_SRV::OpenFileSystemWithPatch, "OpenFileSystemWithPatch"},
+        {7, D<&FSP_SRV::OpenFileSystemWithPatch>, "OpenFileSystemWithPatch"},
         {8, nullptr, "OpenFileSystemWithId"},
         {9, nullptr, "OpenDataFileSystemByApplicationId"},
         {11, nullptr, "OpenBisFileSystem"},
         {12, nullptr, "OpenBisStorage"},
         {13, nullptr, "InvalidateBisCache"},
         {17, nullptr, "OpenHostFileSystem"},
-        {18, &FSP_SRV::OpenSdCardFileSystem, "OpenSdCardFileSystem"},
+        {18, D<&FSP_SRV::OpenSdCardFileSystem>, "OpenSdCardFileSystem"},
         {19, nullptr, "FormatSdCardFileSystem"},
         {21, nullptr, "DeleteSaveDataFileSystem"},
-        {22, &FSP_SRV::CreateSaveDataFileSystem, "CreateSaveDataFileSystem"},
-        {23, &FSP_SRV::CreateSaveDataFileSystemBySystemSaveDataId, "CreateSaveDataFileSystemBySystemSaveDataId"},
+        {22, D<&FSP_SRV::CreateSaveDataFileSystem>, "CreateSaveDataFileSystem"},
+        {23, D<&FSP_SRV::CreateSaveDataFileSystemBySystemSaveDataId>, "CreateSaveDataFileSystemBySystemSaveDataId"},
         {24, nullptr, "RegisterSaveDataFileSystemAtomicDeletion"},
         {25, nullptr, "DeleteSaveDataFileSystemBySaveDataSpaceId"},
         {26, nullptr, "FormatSdCardDryRun"},
@@ -83,26 +72,26 @@ FSP_SRV::FSP_SRV(Core::System& system_)
         {31, nullptr, "OpenGameCardFileSystem"},
         {32, nullptr, "ExtendSaveDataFileSystem"},
         {33, nullptr, "DeleteCacheStorage"},
-        {34, &FSP_SRV::GetCacheStorageSize, "GetCacheStorageSize"},
+        {34, D<&FSP_SRV::GetCacheStorageSize>, "GetCacheStorageSize"},
         {35, nullptr, "CreateSaveDataFileSystemByHashSalt"},
         {36, nullptr, "OpenHostFileSystemWithOption"},
-        {51, &FSP_SRV::OpenSaveDataFileSystem, "OpenSaveDataFileSystem"},
-        {52, &FSP_SRV::OpenSaveDataFileSystemBySystemSaveDataId, "OpenSaveDataFileSystemBySystemSaveDataId"},
-        {53, &FSP_SRV::OpenReadOnlySaveDataFileSystem, "OpenReadOnlySaveDataFileSystem"},
+        {51, D<&FSP_SRV::OpenSaveDataFileSystem>, "OpenSaveDataFileSystem"},
+        {52, D<&FSP_SRV::OpenSaveDataFileSystemBySystemSaveDataId>, "OpenSaveDataFileSystemBySystemSaveDataId"},
+        {53, D<&FSP_SRV::OpenReadOnlySaveDataFileSystem>, "OpenReadOnlySaveDataFileSystem"},
         {57, nullptr, "ReadSaveDataFileSystemExtraDataBySaveDataSpaceId"},
         {58, nullptr, "ReadSaveDataFileSystemExtraData"},
         {59, nullptr, "WriteSaveDataFileSystemExtraData"},
         {60, nullptr, "OpenSaveDataInfoReader"},
-        {61, &FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId, "OpenSaveDataInfoReaderBySaveDataSpaceId"},
-        {62, &FSP_SRV::OpenSaveDataInfoReaderOnlyCacheStorage, "OpenSaveDataInfoReaderOnlyCacheStorage"},
+        {61, D<&FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId>, "OpenSaveDataInfoReaderBySaveDataSpaceId"},
+        {62, D<&FSP_SRV::OpenSaveDataInfoReaderOnlyCacheStorage>, "OpenSaveDataInfoReaderOnlyCacheStorage"},
         {64, nullptr, "OpenSaveDataInternalStorageFileSystem"},
         {65, nullptr, "UpdateSaveDataMacForDebug"},
         {66, nullptr, "WriteSaveDataFileSystemExtraData2"},
         {67, nullptr, "FindSaveDataWithFilter"},
         {68, nullptr, "OpenSaveDataInfoReaderBySaveDataFilter"},
         {69, nullptr, "ReadSaveDataFileSystemExtraDataBySaveDataAttribute"},
-        {70, &FSP_SRV::WriteSaveDataFileSystemExtraDataBySaveDataAttribute, "WriteSaveDataFileSystemExtraDataBySaveDataAttribute"},
-        {71, &FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute, "ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute"},
+        {70, D<&FSP_SRV::WriteSaveDataFileSystemExtraDataBySaveDataAttribute>, "WriteSaveDataFileSystemExtraDataBySaveDataAttribute"},
+        {71, D<&FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute>, "ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute"},
         {80, nullptr, "OpenSaveDataMetaFile"},
         {81, nullptr, "OpenSaveDataTransferManager"},
         {82, nullptr, "OpenSaveDataTransferManagerVersion2"},
@@ -117,12 +106,12 @@ FSP_SRV::FSP_SRV(Core::System& system_)
         {110, nullptr, "OpenContentStorageFileSystem"},
         {120, nullptr, "OpenCloudBackupWorkStorageFileSystem"},
         {130, nullptr, "OpenCustomStorageFileSystem"},
-        {200, &FSP_SRV::OpenDataStorageByCurrentProcess, "OpenDataStorageByCurrentProcess"},
+        {200, D<&FSP_SRV::OpenDataStorageByCurrentProcess>, "OpenDataStorageByCurrentProcess"},
         {201, nullptr, "OpenDataStorageByProgramId"},
-        {202, &FSP_SRV::OpenDataStorageByDataId, "OpenDataStorageByDataId"},
-        {203, &FSP_SRV::OpenPatchDataStorageByCurrentProcess, "OpenPatchDataStorageByCurrentProcess"},
+        {202, D<&FSP_SRV::OpenDataStorageByDataId>, "OpenDataStorageByDataId"},
+        {203, D<&FSP_SRV::OpenPatchDataStorageByCurrentProcess>, "OpenPatchDataStorageByCurrentProcess"},
         {204, nullptr, "OpenDataFileSystemByProgramIndex"},
-        {205, &FSP_SRV::OpenDataStorageWithProgramIndex, "OpenDataStorageWithProgramIndex"},
+        {205, D<&FSP_SRV::OpenDataStorageWithProgramIndex>, "OpenDataStorageWithProgramIndex"},
         {206, nullptr, "OpenDataStorageByPath"},
         {400, nullptr, "OpenDeviceOperator"},
         {500, nullptr, "OpenSdCardDetectionEventNotifier"},
@@ -162,25 +151,25 @@ FSP_SRV::FSP_SRV(Core::System& system_)
         {1000, nullptr, "SetBisRootForHost"},
         {1001, nullptr, "SetSaveDataSize"},
         {1002, nullptr, "SetSaveDataRootPath"},
-        {1003, &FSP_SRV::DisableAutoSaveDataCreation, "DisableAutoSaveDataCreation"},
-        {1004, &FSP_SRV::SetGlobalAccessLogMode, "SetGlobalAccessLogMode"},
-        {1005, &FSP_SRV::GetGlobalAccessLogMode, "GetGlobalAccessLogMode"},
-        {1006, &FSP_SRV::OutputAccessLogToSdCard, "OutputAccessLogToSdCard"},
+        {1003, D<&FSP_SRV::DisableAutoSaveDataCreation>, "DisableAutoSaveDataCreation"},
+        {1004, D<&FSP_SRV::SetGlobalAccessLogMode>, "SetGlobalAccessLogMode"},
+        {1005, D<&FSP_SRV::GetGlobalAccessLogMode>, "GetGlobalAccessLogMode"},
+        {1006, D<&FSP_SRV::OutputAccessLogToSdCard>, "OutputAccessLogToSdCard"},
         {1007, nullptr, "RegisterUpdatePartition"},
         {1008, nullptr, "OpenRegisteredUpdatePartition"},
         {1009, nullptr, "GetAndClearMemoryReportInfo"},
         {1010, nullptr, "SetDataStorageRedirectTarget"},
-        {1011, &FSP_SRV::GetProgramIndexForAccessLog, "GetProgramIndexForAccessLog"},
+        {1011, D<&FSP_SRV::GetProgramIndexForAccessLog>, "GetProgramIndexForAccessLog"},
         {1012, nullptr, "GetFsStackUsage"},
         {1013, nullptr, "UnsetSaveDataRootPath"},
         {1014, nullptr, "OutputMultiProgramTagAccessLog"},
-        {1016, &FSP_SRV::FlushAccessLogOnSdCard, "FlushAccessLogOnSdCard"},
+        {1016, D<&FSP_SRV::FlushAccessLogOnSdCard>, "FlushAccessLogOnSdCard"},
         {1017, nullptr, "OutputApplicationInfoAccessLog"},
         {1018, nullptr, "SetDebugOption"},
         {1019, nullptr, "UnsetDebugOption"},
         {1100, nullptr, "OverrideSaveDataTransferTokenSignVerificationKey"},
         {1110, nullptr, "CorruptSaveDataFileSystemBySaveDataSpaceId2"},
-        {1200, &FSP_SRV::OpenMultiCommitManager, "OpenMultiCommitManager"},
+        {1200, D<&FSP_SRV::OpenMultiCommitManager>, "OpenMultiCommitManager"},
         {1300, nullptr, "OpenBisWiper"},
     };
     // clang-format on
@@ -193,118 +182,77 @@ FSP_SRV::FSP_SRV(Core::System& system_)
 
 FSP_SRV::~FSP_SRV() = default;
 
-void FSP_SRV::SetCurrentProcess(HLERequestContext& ctx) {
-    current_process_id = ctx.GetPID();
+Result FSP_SRV::SetCurrentProcess(ClientProcessId pid) {
+    current_process_id = *pid;
 
     LOG_DEBUG(Service_FS, "called. current_process_id=0x{:016X}", current_process_id);
 
-    const auto res =
-        fsc.OpenProcess(&program_id, &save_data_controller, &romfs_controller, current_process_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(res);
+    R_RETURN(
+        fsc.OpenProcess(&program_id, &save_data_controller, &romfs_controller, current_process_id));
 }
 
-void FSP_SRV::OpenFileSystemWithPatch(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-
-    struct InputParameters {
-        FileSystemProxyType type;
-        u64 program_id;
-    };
-    static_assert(sizeof(InputParameters) == 0x10, "InputParameters has wrong size");
-
-    const auto params = rp.PopRaw<InputParameters>();
-    LOG_ERROR(Service_FS, "(STUBBED) called with type={}, program_id={:016X}", params.type,
-              params.program_id);
+Result FSP_SRV::OpenFileSystemWithPatch(OutInterface<IFileSystem> out_interface,
+                                        FileSystemProxyType type, u64 open_program_id) {
+    LOG_ERROR(Service_FS, "(STUBBED) called with type={}, program_id={:016X}", type,
+              open_program_id);
 
     // FIXME: many issues with this
-    ASSERT(params.type == FileSystemProxyType::Manual);
+    ASSERT(type == FileSystemProxyType::Manual);
     const auto manual_romfs = romfs_controller->OpenPatchedRomFS(
-        params.program_id, FileSys::ContentRecordType::HtmlDocument);
+        open_program_id, FileSys::ContentRecordType::HtmlDocument);
 
     ASSERT(manual_romfs != nullptr);
 
     const auto extracted_romfs = FileSys::ExtractRomFS(manual_romfs);
     ASSERT(extracted_romfs != nullptr);
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IFileSystem>(system, extracted_romfs,
-                                     SizeGetter::FromStorageId(fsc, FileSys::StorageId::NandUser));
+    *out_interface = std::make_shared<IFileSystem>(
+        system, extracted_romfs, SizeGetter::FromStorageId(fsc, FileSys::StorageId::NandUser));
+
+    R_SUCCEED();
 }
 
-void FSP_SRV::OpenSdCardFileSystem(HLERequestContext& ctx) {
+Result FSP_SRV::OpenSdCardFileSystem(OutInterface<IFileSystem> out_interface) {
     LOG_DEBUG(Service_FS, "called");
 
     FileSys::VirtualDir sdmc_dir{};
     fsc.OpenSDMC(&sdmc_dir);
 
-    auto filesystem = std::make_shared<IFileSystem>(
+    *out_interface = std::make_shared<IFileSystem>(
         system, sdmc_dir, SizeGetter::FromStorageId(fsc, FileSys::StorageId::SdCard));
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IFileSystem>(std::move(filesystem));
+    R_SUCCEED();
 }
 
-void FSP_SRV::CreateSaveDataFileSystem(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-
-    auto save_struct = rp.PopRaw<FileSys::SaveDataAttribute>();
-    [[maybe_unused]] auto save_create_struct = rp.PopRaw<std::array<u8, 0x40>>();
-    u128 uid = rp.PopRaw<u128>();
-
+Result FSP_SRV::CreateSaveDataFileSystem(std::array<u8, 0x40> save_create_struct,
+                                         FileSys::SaveDataAttribute save_struct, u128 uid) {
     LOG_DEBUG(Service_FS, "called save_struct = {}, uid = {:016X}{:016X}", save_struct.DebugInfo(),
               uid[1], uid[0]);
 
     FileSys::VirtualDir save_data_dir{};
-    save_data_controller->CreateSaveData(&save_data_dir, FileSys::SaveDataSpaceId::NandUser,
-                                         save_struct);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
+    R_RETURN(save_data_controller->CreateSaveData(&save_data_dir,
+                                                  FileSys::SaveDataSpaceId::NandUser, save_struct));
 }
 
-void FSP_SRV::CreateSaveDataFileSystemBySystemSaveDataId(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-
-    auto save_struct = rp.PopRaw<FileSys::SaveDataAttribute>();
-    [[maybe_unused]] auto save_create_struct = rp.PopRaw<std::array<u8, 0x40>>();
-
+Result FSP_SRV::CreateSaveDataFileSystemBySystemSaveDataId(std::array<u8, 0x40> save_create_struct,
+                                                           FileSys::SaveDataAttribute save_struct) {
     LOG_DEBUG(Service_FS, "called save_struct = {}", save_struct.DebugInfo());
 
     FileSys::VirtualDir save_data_dir{};
-    save_data_controller->CreateSaveData(&save_data_dir, FileSys::SaveDataSpaceId::NandSystem,
-                                         save_struct);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
+    R_RETURN(save_data_controller->CreateSaveData(
+        &save_data_dir, FileSys::SaveDataSpaceId::NandSystem, save_struct));
 }
 
-void FSP_SRV::OpenSaveDataFileSystem(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-
-    struct Parameters {
-        FileSys::SaveDataSpaceId space_id;
-        FileSys::SaveDataAttribute attribute;
-    };
-
-    const auto parameters = rp.PopRaw<Parameters>();
-
+Result FSP_SRV::OpenSaveDataFileSystem(OutInterface<IFileSystem> out_interface,
+                                       FileSys::SaveDataSpaceId space_id,
+                                       FileSys::SaveDataAttribute attribute) {
     LOG_INFO(Service_FS, "called.");
 
     FileSys::VirtualDir dir{};
-    auto result =
-        save_data_controller->OpenSaveData(&dir, parameters.space_id, parameters.attribute);
-    if (result != ResultSuccess) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 0};
-        rb.Push(FileSys::ResultTargetNotFound);
-        return;
-    }
+    R_TRY(save_data_controller->OpenSaveData(&dir, space_id, attribute));
 
     FileSys::StorageId id{};
-    switch (parameters.space_id) {
+    switch (space_id) {
     case FileSys::SaveDataSpaceId::NandUser:
         id = FileSys::StorageId::NandUser;
         break;
@@ -321,106 +269,90 @@ void FSP_SRV::OpenSaveDataFileSystem(HLERequestContext& ctx) {
         ASSERT(false);
     }
 
-    auto filesystem =
+    *out_interface =
         std::make_shared<IFileSystem>(system, std::move(dir), SizeGetter::FromStorageId(fsc, id));
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IFileSystem>(std::move(filesystem));
+    R_SUCCEED();
 }
 
-void FSP_SRV::OpenSaveDataFileSystemBySystemSaveDataId(HLERequestContext& ctx) {
+Result FSP_SRV::OpenSaveDataFileSystemBySystemSaveDataId(OutInterface<IFileSystem> out_interface,
+                                                         FileSys::SaveDataSpaceId space_id,
+                                                         FileSys::SaveDataAttribute attribute) {
     LOG_WARNING(Service_FS, "(STUBBED) called, delegating to 51 OpenSaveDataFilesystem");
-    OpenSaveDataFileSystem(ctx);
+    R_RETURN(OpenSaveDataFileSystem(out_interface, space_id, attribute));
 }
 
-void FSP_SRV::OpenReadOnlySaveDataFileSystem(HLERequestContext& ctx) {
+Result FSP_SRV::OpenReadOnlySaveDataFileSystem(OutInterface<IFileSystem> out_interface,
+                                               FileSys::SaveDataSpaceId space_id,
+                                               FileSys::SaveDataAttribute attribute) {
     LOG_WARNING(Service_FS, "(STUBBED) called, delegating to 51 OpenSaveDataFilesystem");
-    OpenSaveDataFileSystem(ctx);
+    R_RETURN(OpenSaveDataFileSystem(out_interface, space_id, attribute));
 }
 
-void FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto space = rp.PopRaw<FileSys::SaveDataSpaceId>();
+Result FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId(
+    OutInterface<ISaveDataInfoReader> out_interface, FileSys::SaveDataSpaceId space) {
     LOG_INFO(Service_FS, "called, space={}", space);
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISaveDataInfoReader>(
-        std::make_shared<ISaveDataInfoReader>(system, save_data_controller, space));
+    *out_interface = std::make_shared<ISaveDataInfoReader>(system, save_data_controller, space);
+
+    R_SUCCEED();
 }
 
-void FSP_SRV::OpenSaveDataInfoReaderOnlyCacheStorage(HLERequestContext& ctx) {
+Result FSP_SRV::OpenSaveDataInfoReaderOnlyCacheStorage(
+    OutInterface<ISaveDataInfoReader> out_interface) {
     LOG_WARNING(Service_FS, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISaveDataInfoReader>(system, save_data_controller,
-                                             FileSys::SaveDataSpaceId::TemporaryStorage);
+    *out_interface = std::make_shared<ISaveDataInfoReader>(
+        system, save_data_controller, FileSys::SaveDataSpaceId::TemporaryStorage);
+
+    R_SUCCEED();
 }
 
-void FSP_SRV::WriteSaveDataFileSystemExtraDataBySaveDataAttribute(HLERequestContext& ctx) {
+Result FSP_SRV::WriteSaveDataFileSystemExtraDataBySaveDataAttribute() {
     LOG_WARNING(Service_FS, "(STUBBED) called.");
 
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
+    R_SUCCEED();
 }
 
-void FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-
-    struct Parameters {
-        FileSys::SaveDataSpaceId space_id;
-        FileSys::SaveDataAttribute attribute;
-    };
-
-    const auto parameters = rp.PopRaw<Parameters>();
+Result FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
+    FileSys::SaveDataSpaceId space_id, FileSys::SaveDataAttribute attribute,
+    InBuffer<BufferAttr_HipcMapAlias> mask_buffer, OutBuffer<BufferAttr_HipcMapAlias> out_buffer) {
     // Stub this to None for now, backend needs an impl to read/write the SaveDataExtraData
-    constexpr auto flags = static_cast<u32>(FileSys::SaveDataFlags::None);
+    // In an earlier version of the code, this was returned as an out argument, but this is not
+    // correct
+    [[maybe_unused]] constexpr auto flags = static_cast<u32>(FileSys::SaveDataFlags::None);
 
     LOG_WARNING(Service_FS,
                 "(STUBBED) called, flags={}, space_id={}, attribute.title_id={:016X}\n"
                 "attribute.user_id={:016X}{:016X}, attribute.save_id={:016X}\n"
                 "attribute.type={}, attribute.rank={}, attribute.index={}",
-                flags, parameters.space_id, parameters.attribute.title_id,
-                parameters.attribute.user_id[1], parameters.attribute.user_id[0],
-                parameters.attribute.save_id, parameters.attribute.type, parameters.attribute.rank,
-                parameters.attribute.index);
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push(flags);
+                flags, space_id, attribute.title_id, attribute.user_id[1], attribute.user_id[0],
+                attribute.save_id, attribute.type, attribute.rank, attribute.index);
+
+    R_SUCCEED();
 }
 
-void FSP_SRV::OpenDataStorageByCurrentProcess(HLERequestContext& ctx) {
+Result FSP_SRV::OpenDataStorageByCurrentProcess(OutInterface<IStorage> out_interface) {
     LOG_DEBUG(Service_FS, "called");
 
     if (!romfs) {
         auto current_romfs = romfs_controller->OpenRomFSCurrentProcess();
         if (!current_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};
-            rb.Push(ResultUnknown);
-            return;
+            LOG_CRITICAL(Service_FS, "No file system interface available!");
+            R_RETURN(ResultUnknown);
         }
 
         romfs = current_romfs;
     }
 
-    auto storage = std::make_shared<IStorage>(system, romfs);
+    *out_interface = std::make_shared<IStorage>(system, romfs);
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IStorage>(std::move(storage));
+    R_SUCCEED();
 }
 
-void FSP_SRV::OpenDataStorageByDataId(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto storage_id = rp.PopRaw<FileSys::StorageId>();
-    const auto unknown = rp.PopRaw<u32>();
-    const auto title_id = rp.PopRaw<u64>();
-
+Result FSP_SRV::OpenDataStorageByDataId(OutInterface<IStorage> out_interface,
+                                        FileSys::StorageId storage_id, u32 unknown, u64 title_id) {
     LOG_DEBUG(Service_FS, "called with storage_id={:02X}, unknown={:08X}, title_id={:016X}",
               storage_id, unknown, title_id);
 
@@ -430,19 +362,15 @@ void FSP_SRV::OpenDataStorageByDataId(HLERequestContext& ctx) {
         const auto archive = FileSys::SystemArchive::SynthesizeSystemArchive(title_id);
 
         if (archive != nullptr) {
-            IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-            rb.Push(ResultSuccess);
-            rb.PushIpcInterface(std::make_shared<IStorage>(system, archive));
-            return;
+            *out_interface = std::make_shared<IStorage>(system, archive);
+            R_SUCCEED();
         }
 
         // TODO(DarkLordZach): Find the right error code to use here
         LOG_ERROR(Service_FS,
-                  "could not open data storage with title_id={:016X}, storage_id={:02X}", title_id,
+                  "Could not open data storage with title_id={:016X}, storage_id={:02X}", title_id,
                   storage_id);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultUnknown);
-        return;
+        R_RETURN(ResultUnknown);
     }
 
     const FileSys::PatchManager pm{title_id, fsc, content_provider};
@@ -452,28 +380,20 @@ void FSP_SRV::OpenDataStorageByDataId(HLERequestContext& ctx) {
     auto storage = std::make_shared<IStorage>(
         system, pm.PatchRomFS(base.get(), std::move(data), FileSys::ContentRecordType::Data));
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IStorage>(std::move(storage));
+    *out_interface = std::move(storage);
+    R_SUCCEED();
 }
 
-void FSP_SRV::OpenPatchDataStorageByCurrentProcess(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
+Result FSP_SRV::OpenPatchDataStorageByCurrentProcess(OutInterface<IStorage> out_interface,
+                                                     FileSys::StorageId storage_id, u64 title_id) {
+    LOG_WARNING(Service_FS, "(STUBBED) called with storage_id={:02X}, title_id={:016X}", storage_id,
+                title_id);
 
-    const auto storage_id = rp.PopRaw<FileSys::StorageId>();
-    const auto title_id = rp.PopRaw<u64>();
-
-    LOG_DEBUG(Service_FS, "called with storage_id={:02X}, title_id={:016X}", storage_id, title_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(FileSys::ResultTargetNotFound);
+    R_RETURN(FileSys::ResultTargetNotFound);
 }
 
-void FSP_SRV::OpenDataStorageWithProgramIndex(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-
-    const auto program_index = rp.PopRaw<u8>();
-
+Result FSP_SRV::OpenDataStorageWithProgramIndex(OutInterface<IStorage> out_interface,
+                                                u8 program_index) {
     LOG_DEBUG(Service_FS, "called, program_index={}", program_index);
 
     auto patched_romfs = romfs_controller->OpenPatchedRomFSWithProgramIndex(
@@ -481,94 +401,80 @@ void FSP_SRV::OpenDataStorageWithProgramIndex(HLERequestContext& ctx) {
 
     if (!patched_romfs) {
         // TODO: Find the right error code to use here
-        LOG_ERROR(Service_FS, "could not open storage with program_index={}", program_index);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultUnknown);
-        return;
+        LOG_ERROR(Service_FS, "Could not open storage with program_index={}", program_index);
+        R_RETURN(ResultUnknown);
     }
 
-    auto storage = std::make_shared<IStorage>(system, std::move(patched_romfs));
+    *out_interface = std::make_shared<IStorage>(system, std::move(patched_romfs));
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IStorage>(std::move(storage));
+    R_SUCCEED();
 }
 
-void FSP_SRV::DisableAutoSaveDataCreation(HLERequestContext& ctx) {
+Result FSP_SRV::DisableAutoSaveDataCreation() {
     LOG_DEBUG(Service_FS, "called");
 
     save_data_controller->SetAutoCreate(false);
 
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
+    R_SUCCEED();
 }
 
-void FSP_SRV::SetGlobalAccessLogMode(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    access_log_mode = rp.PopEnum<AccessLogMode>();
+Result FSP_SRV::SetGlobalAccessLogMode(AccessLogMode access_log_mode_) {
+    LOG_DEBUG(Service_FS, "called, access_log_mode={}", access_log_mode_);
 
-    LOG_DEBUG(Service_FS, "called, access_log_mode={}", access_log_mode);
+    access_log_mode = access_log_mode_;
 
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
+    R_SUCCEED();
 }
 
-void FSP_SRV::GetGlobalAccessLogMode(HLERequestContext& ctx) {
+Result FSP_SRV::GetGlobalAccessLogMode(Out<AccessLogMode> out_access_log_mode) {
     LOG_DEBUG(Service_FS, "called");
 
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.PushEnum(access_log_mode);
-}
+    *out_access_log_mode = access_log_mode;
 
-void FSP_SRV::OutputAccessLogToSdCard(HLERequestContext& ctx) {
-    const auto raw = ctx.ReadBufferCopy();
-    auto log = Common::StringFromFixedZeroTerminatedBuffer(
-        reinterpret_cast<const char*>(raw.data()), raw.size());
+    R_SUCCEED();
+}
 
+Result FSP_SRV::OutputAccessLogToSdCard(InBuffer<BufferAttr_HipcMapAlias> log_message_buffer) {
     LOG_DEBUG(Service_FS, "called");
 
+    auto log = Common::StringFromFixedZeroTerminatedBuffer(
+        reinterpret_cast<const char*>(log_message_buffer.data()), log_message_buffer.size());
     reporter.SaveFSAccessLog(log);
 
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
+    R_SUCCEED();
 }
 
-void FSP_SRV::GetProgramIndexForAccessLog(HLERequestContext& ctx) {
-    LOG_DEBUG(Service_FS, "called");
+Result FSP_SRV::GetProgramIndexForAccessLog(Out<AccessLogVersion> out_access_log_version,
+                                            Out<u32> out_access_log_program_index) {
+    LOG_DEBUG(Service_FS, "(STUBBED) called");
+
+    *out_access_log_version = AccessLogVersion::Latest;
+    *out_access_log_program_index = access_log_program_index;
 
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(ResultSuccess);
-    rb.PushEnum(AccessLogVersion::Latest);
-    rb.Push(access_log_program_index);
+    R_SUCCEED();
 }
 
-void FSP_SRV::FlushAccessLogOnSdCard(HLERequestContext& ctx) {
+Result FSP_SRV::FlushAccessLogOnSdCard() {
     LOG_DEBUG(Service_FS, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
+    R_SUCCEED();
 }
 
-void FSP_SRV::GetCacheStorageSize(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto index{rp.Pop<s32>()};
-
+Result FSP_SRV::GetCacheStorageSize(s32 index, Out<s64> out_data_size, Out<s64> out_journal_size) {
     LOG_WARNING(Service_FS, "(STUBBED) called with index={}", index);
 
-    IPC::ResponseBuilder rb{ctx, 6};
-    rb.Push(ResultSuccess);
-    rb.Push(s64{0});
-    rb.Push(s64{0});
+    *out_data_size = 0;
+    *out_journal_size = 0;
+
+    R_SUCCEED();
 }
 
-void FSP_SRV::OpenMultiCommitManager(HLERequestContext& ctx) {
+Result FSP_SRV::OpenMultiCommitManager(OutInterface<IMultiCommitManager> out_interface) {
     LOG_DEBUG(Service_FS, "called");
 
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IMultiCommitManager>(std::make_shared<IMultiCommitManager>(system));
+    *out_interface = std::make_shared<IMultiCommitManager>(system);
+
+    R_SUCCEED();
 }
 
 } // namespace Service::FileSystem
diff --git a/src/core/hle/service/filesystem/fsp/fsp_srv.h b/src/core/hle/service/filesystem/fsp/fsp_srv.h
index 59406e6f9..0669c4922 100644
--- a/src/core/hle/service/filesystem/fsp/fsp_srv.h
+++ b/src/core/hle/service/filesystem/fsp/fsp_srv.h
@@ -4,6 +4,7 @@
 #pragma once
 
 #include <memory>
+#include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 
 namespace Core {
@@ -20,6 +21,11 @@ namespace Service::FileSystem {
 class RomFsController;
 class SaveDataController;
 
+class IFileSystem;
+class ISaveDataInfoReader;
+class IStorage;
+class IMultiCommitManager;
+
 enum class AccessLogVersion : u32 {
     V7_0_0 = 2,
 
@@ -32,36 +38,64 @@ enum class AccessLogMode : u32 {
     SdCard,
 };
 
+enum class FileSystemProxyType : u8 {
+    Code = 0,
+    Rom = 1,
+    Logo = 2,
+    Control = 3,
+    Manual = 4,
+    Meta = 5,
+    Data = 6,
+    Package = 7,
+    RegisteredUpdate = 8,
+};
+
 class FSP_SRV final : public ServiceFramework<FSP_SRV> {
 public:
     explicit FSP_SRV(Core::System& system_);
     ~FSP_SRV() override;
 
 private:
-    void SetCurrentProcess(HLERequestContext& ctx);
-    void OpenFileSystemWithPatch(HLERequestContext& ctx);
-    void OpenSdCardFileSystem(HLERequestContext& ctx);
-    void CreateSaveDataFileSystem(HLERequestContext& ctx);
-    void CreateSaveDataFileSystemBySystemSaveDataId(HLERequestContext& ctx);
-    void OpenSaveDataFileSystem(HLERequestContext& ctx);
-    void OpenSaveDataFileSystemBySystemSaveDataId(HLERequestContext& ctx);
-    void OpenReadOnlySaveDataFileSystem(HLERequestContext& ctx);
-    void OpenSaveDataInfoReaderBySaveDataSpaceId(HLERequestContext& ctx);
-    void OpenSaveDataInfoReaderOnlyCacheStorage(HLERequestContext& ctx);
-    void WriteSaveDataFileSystemExtraDataBySaveDataAttribute(HLERequestContext& ctx);
-    void ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(HLERequestContext& ctx);
-    void OpenDataStorageByCurrentProcess(HLERequestContext& ctx);
-    void OpenDataStorageByDataId(HLERequestContext& ctx);
-    void OpenPatchDataStorageByCurrentProcess(HLERequestContext& ctx);
-    void OpenDataStorageWithProgramIndex(HLERequestContext& ctx);
-    void DisableAutoSaveDataCreation(HLERequestContext& ctx);
-    void SetGlobalAccessLogMode(HLERequestContext& ctx);
-    void GetGlobalAccessLogMode(HLERequestContext& ctx);
-    void OutputAccessLogToSdCard(HLERequestContext& ctx);
-    void FlushAccessLogOnSdCard(HLERequestContext& ctx);
-    void GetProgramIndexForAccessLog(HLERequestContext& ctx);
-    void OpenMultiCommitManager(HLERequestContext& ctx);
-    void GetCacheStorageSize(HLERequestContext& ctx);
+    Result SetCurrentProcess(ClientProcessId pid);
+    Result OpenFileSystemWithPatch(OutInterface<IFileSystem> out_interface,
+                                   FileSystemProxyType type, u64 open_program_id);
+    Result OpenSdCardFileSystem(OutInterface<IFileSystem> out_interface);
+    Result CreateSaveDataFileSystem(std::array<u8, 0x40> save_create_struct,
+                                    FileSys::SaveDataAttribute save_struct, u128 uid);
+    Result CreateSaveDataFileSystemBySystemSaveDataId(std::array<u8, 0x40> save_create_struct,
+                                                      FileSys::SaveDataAttribute save_struct);
+    Result OpenSaveDataFileSystem(OutInterface<IFileSystem> out_interface,
+                                  FileSys::SaveDataSpaceId space_id,
+                                  FileSys::SaveDataAttribute attribute);
+    Result OpenSaveDataFileSystemBySystemSaveDataId(OutInterface<IFileSystem> out_interface,
+                                                    FileSys::SaveDataSpaceId space_id,
+                                                    FileSys::SaveDataAttribute attribute);
+    Result OpenReadOnlySaveDataFileSystem(OutInterface<IFileSystem> out_interface,
+                                          FileSys::SaveDataSpaceId space_id,
+                                          FileSys::SaveDataAttribute attribute);
+    Result OpenSaveDataInfoReaderBySaveDataSpaceId(OutInterface<ISaveDataInfoReader> out_interface,
+                                                   FileSys::SaveDataSpaceId space);
+    Result OpenSaveDataInfoReaderOnlyCacheStorage(OutInterface<ISaveDataInfoReader> out_interface);
+    Result WriteSaveDataFileSystemExtraDataBySaveDataAttribute();
+    Result ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
+        FileSys::SaveDataSpaceId space_id, FileSys::SaveDataAttribute attribute,
+        InBuffer<BufferAttr_HipcMapAlias> mask_buffer,
+        OutBuffer<BufferAttr_HipcMapAlias> out_buffer);
+    Result OpenDataStorageByCurrentProcess(OutInterface<IStorage> out_interface);
+    Result OpenDataStorageByDataId(OutInterface<IStorage> out_interface,
+                                   FileSys::StorageId storage_id, u32 unknown, u64 title_id);
+    Result OpenPatchDataStorageByCurrentProcess(OutInterface<IStorage> out_interface,
+                                                FileSys::StorageId storage_id, u64 title_id);
+    Result OpenDataStorageWithProgramIndex(OutInterface<IStorage> out_interface, u8 program_index);
+    Result DisableAutoSaveDataCreation();
+    Result SetGlobalAccessLogMode(AccessLogMode access_log_mode_);
+    Result GetGlobalAccessLogMode(Out<AccessLogMode> out_access_log_mode);
+    Result OutputAccessLogToSdCard(InBuffer<BufferAttr_HipcMapAlias> log_message_buffer);
+    Result FlushAccessLogOnSdCard();
+    Result GetProgramIndexForAccessLog(Out<AccessLogVersion> out_access_log_version,
+                                       Out<u32> out_access_log_program_index);
+    Result OpenMultiCommitManager(OutInterface<IMultiCommitManager> out_interface);
+    Result GetCacheStorageSize(s32 index, Out<s64> out_data_size, Out<s64> out_journal_size);
 
     FileSystemController& fsc;
     const FileSys::ContentProvider& content_provider;
-- 
cgit v1.2.3


From 4c71bf3d907efaeb97bc2b0461bece520a91d198 Mon Sep 17 00:00:00 2001
From: FearlessTobi <thm.frey@gmail.com>
Date: Mon, 19 Feb 2024 02:58:25 +0100
Subject: fsp: Migrate remaining interfaces to cmif serialization

---
 .../filesystem/fsp/fs_i_multi_commit_manager.cpp   | 16 ++++----
 .../filesystem/fsp/fs_i_multi_commit_manager.h     |  4 +-
 .../filesystem/fsp/fs_i_save_data_info_reader.cpp  | 20 ++++-----
 .../filesystem/fsp/fs_i_save_data_info_reader.h    | 16 ++++----
 .../hle/service/filesystem/fsp/fs_i_storage.cpp    | 47 +++++++---------------
 src/core/hle/service/filesystem/fsp/fs_i_storage.h |  7 +++-
 6 files changed, 48 insertions(+), 62 deletions(-)

(limited to 'src/core/hle/service/filesystem/fsp')

diff --git a/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.cpp b/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.cpp
index 054bf5054..13914b5e1 100644
--- a/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.cpp
+++ b/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.cpp
@@ -1,34 +1,32 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h"
-#include "core/hle/service/ipc_helpers.h"
 
 namespace Service::FileSystem {
 
 IMultiCommitManager::IMultiCommitManager(Core::System& system_)
     : ServiceFramework{system_, "IMultiCommitManager"} {
     static const FunctionInfo functions[] = {
-        {1, &IMultiCommitManager::Add, "Add"},
-        {2, &IMultiCommitManager::Commit, "Commit"},
+        {1, D<&IMultiCommitManager::Add>, "Add"},
+        {2, D<&IMultiCommitManager::Commit>, "Commit"},
     };
     RegisterHandlers(functions);
 }
 
 IMultiCommitManager::~IMultiCommitManager() = default;
 
-void IMultiCommitManager::Add(HLERequestContext& ctx) {
+Result IMultiCommitManager::Add() {
     LOG_WARNING(Service_FS, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
+    R_SUCCEED();
 }
 
-void IMultiCommitManager::Commit(HLERequestContext& ctx) {
+Result IMultiCommitManager::Commit() {
     LOG_WARNING(Service_FS, "(STUBBED) called");
 
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
+    R_SUCCEED();
 }
 
 } // namespace Service::FileSystem
diff --git a/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h b/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h
index 6124873b3..274ef0513 100644
--- a/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h
+++ b/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h
@@ -14,8 +14,8 @@ public:
     ~IMultiCommitManager() override;
 
 private:
-    void Add(HLERequestContext& ctx);
-    void Commit(HLERequestContext& ctx);
+    Result Add();
+    Result Commit();
 
     FileSys::VirtualFile backend;
 };
diff --git a/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp b/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp
index 872377d03..0d9b0dcaf 100644
--- a/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp
+++ b/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp
@@ -3,19 +3,19 @@
 
 #include "common/hex_util.h"
 #include "core/file_sys/savedata_factory.h"
+#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h"
 #include "core/hle/service/filesystem/save_data_controller.h"
-#include "core/hle/service/ipc_helpers.h"
 
 namespace Service::FileSystem {
 
 ISaveDataInfoReader::ISaveDataInfoReader(Core::System& system_,
                                          std::shared_ptr<SaveDataController> save_data_controller_,
                                          FileSys::SaveDataSpaceId space)
-    : ServiceFramework{system_, "ISaveDataInfoReader"},
-      save_data_controller{save_data_controller_} {
+    : ServiceFramework{system_, "ISaveDataInfoReader"}, save_data_controller{
+                                                            save_data_controller_} {
     static const FunctionInfo functions[] = {
-        {0, &ISaveDataInfoReader::ReadSaveDataInfo, "ReadSaveDataInfo"},
+        {0, D<&ISaveDataInfoReader::ReadSaveDataInfo>, "ReadSaveDataInfo"},
     };
     RegisterHandlers(functions);
 
@@ -36,11 +36,12 @@ static u64 stoull_be(std::string_view str) {
     return Common::swap64(out);
 }
 
-void ISaveDataInfoReader::ReadSaveDataInfo(HLERequestContext& ctx) {
+Result ISaveDataInfoReader::ReadSaveDataInfo(
+    Out<u64> out_count, OutArray<SaveDataInfo, BufferAttr_HipcMapAlias> out_entries) {
     LOG_DEBUG(Service_FS, "called");
 
     // Calculate how many entries we can fit in the output buffer
-    const u64 count_entries = ctx.GetWriteBufferNumElements<SaveDataInfo>();
+    const u64 count_entries = out_entries.size();
 
     // Cap at total number of entries.
     const u64 actual_entries = std::min(count_entries, info.size() - next_entry_index);
@@ -53,11 +54,10 @@ void ISaveDataInfoReader::ReadSaveDataInfo(HLERequestContext& ctx) {
     next_entry_index += actual_entries;
 
     // Write the data to memory
-    ctx.WriteBuffer(begin, range_size);
+    std::memcpy(out_entries.data(), begin, range_size);
+    *out_count = actual_entries;
 
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(ResultSuccess);
-    rb.Push<u64>(actual_entries);
+    R_SUCCEED();
 }
 
 void ISaveDataInfoReader::FindAllSaves(FileSys::SaveDataSpaceId space) {
diff --git a/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h b/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h
index 86e09973b..7b21b029b 100644
--- a/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h
+++ b/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h
@@ -5,6 +5,7 @@
 
 #include <vector>
 #include "common/common_types.h"
+#include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 
 namespace Service::FileSystem {
@@ -18,13 +19,6 @@ public:
                                  FileSys::SaveDataSpaceId space);
     ~ISaveDataInfoReader() override;
 
-    void ReadSaveDataInfo(HLERequestContext& ctx);
-
-private:
-    void FindAllSaves(FileSys::SaveDataSpaceId space);
-    void FindNormalSaves(FileSys::SaveDataSpaceId space, const FileSys::VirtualDir& type);
-    void FindTemporaryStorageSaves(FileSys::SaveDataSpaceId space, const FileSys::VirtualDir& type);
-
     struct SaveDataInfo {
         u64_le save_id_unknown;
         FileSys::SaveDataSpaceId space;
@@ -40,6 +34,14 @@ private:
     };
     static_assert(sizeof(SaveDataInfo) == 0x60, "SaveDataInfo has incorrect size.");
 
+    Result ReadSaveDataInfo(Out<u64> out_count,
+                            OutArray<SaveDataInfo, BufferAttr_HipcMapAlias> out_entries);
+
+private:
+    void FindAllSaves(FileSys::SaveDataSpaceId space);
+    void FindNormalSaves(FileSys::SaveDataSpaceId space, const FileSys::VirtualDir& type);
+    void FindTemporaryStorageSaves(FileSys::SaveDataSpaceId space, const FileSys::VirtualDir& type);
+
     std::shared_ptr<SaveDataController> save_data_controller;
     std::vector<SaveDataInfo> info;
     u64 next_entry_index = 0;
diff --git a/src/core/hle/service/filesystem/fsp/fs_i_storage.cpp b/src/core/hle/service/filesystem/fsp/fs_i_storage.cpp
index 98223c1f9..213f19808 100644
--- a/src/core/hle/service/filesystem/fsp/fs_i_storage.cpp
+++ b/src/core/hle/service/filesystem/fsp/fs_i_storage.cpp
@@ -2,61 +2,44 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/file_sys/errors.h"
+#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/filesystem/fsp/fs_i_storage.h"
-#include "core/hle/service/ipc_helpers.h"
 
 namespace Service::FileSystem {
 
 IStorage::IStorage(Core::System& system_, FileSys::VirtualFile backend_)
     : ServiceFramework{system_, "IStorage"}, backend(std::move(backend_)) {
     static const FunctionInfo functions[] = {
-        {0, &IStorage::Read, "Read"},
+        {0, D<&IStorage::Read>, "Read"},
         {1, nullptr, "Write"},
         {2, nullptr, "Flush"},
         {3, nullptr, "SetSize"},
-        {4, &IStorage::GetSize, "GetSize"},
+        {4, D<&IStorage::GetSize>, "GetSize"},
         {5, nullptr, "OperateRange"},
     };
     RegisterHandlers(functions);
 }
 
-void IStorage::Read(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const s64 offset = rp.Pop<s64>();
-    const s64 length = rp.Pop<s64>();
-
+Result IStorage::Read(
+    OutBuffer<BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure> out_bytes,
+    s64 offset, s64 length) {
     LOG_DEBUG(Service_FS, "called, offset=0x{:X}, length={}", offset, length);
 
-    // Error checking
-    if (length < 0) {
-        LOG_ERROR(Service_FS, "Length is less than 0, length={}", length);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(FileSys::ResultInvalidSize);
-        return;
-    }
-    if (offset < 0) {
-        LOG_ERROR(Service_FS, "Offset is less than 0, offset={}", offset);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(FileSys::ResultInvalidOffset);
-        return;
-    }
+    R_UNLESS(length >= 0, FileSys::ResultInvalidSize);
+    R_UNLESS(offset >= 0, FileSys::ResultInvalidOffset);
 
     // Read the data from the Storage backend
-    std::vector<u8> output = backend->ReadBytes(length, offset);
-    // Write the data to memory
-    ctx.WriteBuffer(output);
+    backend->Read(out_bytes.data(), length, offset);
 
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
+    R_SUCCEED();
 }
 
-void IStorage::GetSize(HLERequestContext& ctx) {
-    const u64 size = backend->GetSize();
-    LOG_DEBUG(Service_FS, "called, size={}", size);
+Result IStorage::GetSize(Out<u64> out_size) {
+    *out_size = backend->GetSize();
+
+    LOG_DEBUG(Service_FS, "called, size={}", *out_size);
 
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(ResultSuccess);
-    rb.Push<u64>(size);
+    R_SUCCEED();
 }
 
 } // namespace Service::FileSystem
diff --git a/src/core/hle/service/filesystem/fsp/fs_i_storage.h b/src/core/hle/service/filesystem/fsp/fs_i_storage.h
index cb5bebcc9..74d879386 100644
--- a/src/core/hle/service/filesystem/fsp/fs_i_storage.h
+++ b/src/core/hle/service/filesystem/fsp/fs_i_storage.h
@@ -4,6 +4,7 @@
 #pragma once
 
 #include "core/file_sys/vfs/vfs.h"
+#include "core/hle/service/cmif_types.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/service.h"
 
@@ -16,8 +17,10 @@ public:
 private:
     FileSys::VirtualFile backend;
 
-    void Read(HLERequestContext& ctx);
-    void GetSize(HLERequestContext& ctx);
+    Result Read(
+        OutBuffer<BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure> out_bytes,
+        s64 offset, s64 length);
+    Result GetSize(Out<u64> out_size);
 };
 
 } // namespace Service::FileSystem
-- 
cgit v1.2.3


From 2b18957365d8f369626ec3b94277621df2fe1729 Mon Sep 17 00:00:00 2001
From: FearlessTobi <thm.frey@gmail.com>
Date: Mon, 19 Feb 2024 15:36:20 +0100
Subject: fs: Add and use fs_save_data_types.h

---
 .../filesystem/fsp/fs_i_save_data_info_reader.cpp  |  9 +++---
 src/core/hle/service/filesystem/fsp/fsp_srv.cpp    | 34 +++++++++++-----------
 src/core/hle/service/filesystem/fsp/fsp_srv.h      |  7 +++--
 3 files changed, 25 insertions(+), 25 deletions(-)

(limited to 'src/core/hle/service/filesystem/fsp')

diff --git a/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp b/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp
index 0d9b0dcaf..ff823586b 100644
--- a/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp
+++ b/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp
@@ -72,7 +72,7 @@ void ISaveDataInfoReader::FindAllSaves(FileSys::SaveDataSpaceId space) {
     for (const auto& type : save_root->GetSubdirectories()) {
         if (type->GetName() == "save") {
             FindNormalSaves(space, type);
-        } else if (space == FileSys::SaveDataSpaceId::TemporaryStorage) {
+        } else if (space == FileSys::SaveDataSpaceId::Temporary) {
             FindTemporaryStorageSaves(space, type);
         }
     }
@@ -96,7 +96,7 @@ void ISaveDataInfoReader::FindNormalSaves(FileSys::SaveDataSpaceId space,
                 info.emplace_back(SaveDataInfo{
                     0,
                     space,
-                    FileSys::SaveDataType::SystemSaveData,
+                    FileSys::SaveDataType::System,
                     {},
                     user_id_numeric,
                     save_id_numeric,
@@ -115,8 +115,7 @@ void ISaveDataInfoReader::FindNormalSaves(FileSys::SaveDataSpaceId space,
                 info.emplace_back(SaveDataInfo{
                     0,
                     space,
-                    device ? FileSys::SaveDataType::DeviceSaveData
-                           : FileSys::SaveDataType::SaveData,
+                    device ? FileSys::SaveDataType::Device : FileSys::SaveDataType::Account,
                     {},
                     user_id_numeric,
                     save_id_numeric,
@@ -145,7 +144,7 @@ void ISaveDataInfoReader::FindTemporaryStorageSaves(FileSys::SaveDataSpaceId spa
                 info.emplace_back(SaveDataInfo{
                     0,
                     space,
-                    FileSys::SaveDataType::TemporaryStorage,
+                    FileSys::SaveDataType::Temporary,
                     {},
                     user_id_numeric,
                     stoull_be(type->GetName()),
diff --git a/src/core/hle/service/filesystem/fsp/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp/fsp_srv.cpp
index 2f3b01595..fc67a4713 100644
--- a/src/core/hle/service/filesystem/fsp/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp/fsp_srv.cpp
@@ -224,23 +224,23 @@ Result FSP_SRV::OpenSdCardFileSystem(OutInterface<IFileSystem> out_interface) {
     R_SUCCEED();
 }
 
-Result FSP_SRV::CreateSaveDataFileSystem(std::array<u8, 0x40> save_create_struct,
+Result FSP_SRV::CreateSaveDataFileSystem(FileSys::SaveDataCreationInfo save_create_struct,
                                          FileSys::SaveDataAttribute save_struct, u128 uid) {
     LOG_DEBUG(Service_FS, "called save_struct = {}, uid = {:016X}{:016X}", save_struct.DebugInfo(),
               uid[1], uid[0]);
 
     FileSys::VirtualDir save_data_dir{};
-    R_RETURN(save_data_controller->CreateSaveData(&save_data_dir,
-                                                  FileSys::SaveDataSpaceId::NandUser, save_struct));
+    R_RETURN(save_data_controller->CreateSaveData(&save_data_dir, FileSys::SaveDataSpaceId::User,
+                                                  save_struct));
 }
 
-Result FSP_SRV::CreateSaveDataFileSystemBySystemSaveDataId(std::array<u8, 0x40> save_create_struct,
-                                                           FileSys::SaveDataAttribute save_struct) {
+Result FSP_SRV::CreateSaveDataFileSystemBySystemSaveDataId(
+    FileSys::SaveDataCreationInfo save_create_struct, FileSys::SaveDataAttribute save_struct) {
     LOG_DEBUG(Service_FS, "called save_struct = {}", save_struct.DebugInfo());
 
     FileSys::VirtualDir save_data_dir{};
-    R_RETURN(save_data_controller->CreateSaveData(
-        &save_data_dir, FileSys::SaveDataSpaceId::NandSystem, save_struct));
+    R_RETURN(save_data_controller->CreateSaveData(&save_data_dir, FileSys::SaveDataSpaceId::System,
+                                                  save_struct));
 }
 
 Result FSP_SRV::OpenSaveDataFileSystem(OutInterface<IFileSystem> out_interface,
@@ -253,17 +253,17 @@ Result FSP_SRV::OpenSaveDataFileSystem(OutInterface<IFileSystem> out_interface,
 
     FileSys::StorageId id{};
     switch (space_id) {
-    case FileSys::SaveDataSpaceId::NandUser:
+    case FileSys::SaveDataSpaceId::User:
         id = FileSys::StorageId::NandUser;
         break;
-    case FileSys::SaveDataSpaceId::SdCardSystem:
-    case FileSys::SaveDataSpaceId::SdCardUser:
+    case FileSys::SaveDataSpaceId::SdSystem:
+    case FileSys::SaveDataSpaceId::SdUser:
         id = FileSys::StorageId::SdCard;
         break;
-    case FileSys::SaveDataSpaceId::NandSystem:
+    case FileSys::SaveDataSpaceId::System:
         id = FileSys::StorageId::NandSystem;
         break;
-    case FileSys::SaveDataSpaceId::TemporaryStorage:
+    case FileSys::SaveDataSpaceId::Temporary:
     case FileSys::SaveDataSpaceId::ProperSystem:
     case FileSys::SaveDataSpaceId::SafeMode:
         ASSERT(false);
@@ -302,8 +302,8 @@ Result FSP_SRV::OpenSaveDataInfoReaderOnlyCacheStorage(
     OutInterface<ISaveDataInfoReader> out_interface) {
     LOG_WARNING(Service_FS, "(STUBBED) called");
 
-    *out_interface = std::make_shared<ISaveDataInfoReader>(
-        system, save_data_controller, FileSys::SaveDataSpaceId::TemporaryStorage);
+    *out_interface = std::make_shared<ISaveDataInfoReader>(system, save_data_controller,
+                                                           FileSys::SaveDataSpaceId::Temporary);
 
     R_SUCCEED();
 }
@@ -323,11 +323,11 @@ Result FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
     [[maybe_unused]] constexpr auto flags = static_cast<u32>(FileSys::SaveDataFlags::None);
 
     LOG_WARNING(Service_FS,
-                "(STUBBED) called, flags={}, space_id={}, attribute.title_id={:016X}\n"
+                "(STUBBED) called, flags={}, space_id={}, attribute.program_id={:016X}\n"
                 "attribute.user_id={:016X}{:016X}, attribute.save_id={:016X}\n"
                 "attribute.type={}, attribute.rank={}, attribute.index={}",
-                flags, space_id, attribute.title_id, attribute.user_id[1], attribute.user_id[0],
-                attribute.save_id, attribute.type, attribute.rank, attribute.index);
+                flags, space_id, attribute.program_id, attribute.user_id[1], attribute.user_id[0],
+                attribute.system_save_data_id, attribute.type, attribute.rank, attribute.index);
 
     R_SUCCEED();
 }
diff --git a/src/core/hle/service/filesystem/fsp/fsp_srv.h b/src/core/hle/service/filesystem/fsp/fsp_srv.h
index 0669c4922..7a29d17c9 100644
--- a/src/core/hle/service/filesystem/fsp/fsp_srv.h
+++ b/src/core/hle/service/filesystem/fsp/fsp_srv.h
@@ -4,6 +4,7 @@
 #pragma once
 
 #include <memory>
+#include "core/file_sys/fs_save_data_types.h"
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 
@@ -60,10 +61,10 @@ private:
     Result OpenFileSystemWithPatch(OutInterface<IFileSystem> out_interface,
                                    FileSystemProxyType type, u64 open_program_id);
     Result OpenSdCardFileSystem(OutInterface<IFileSystem> out_interface);
-    Result CreateSaveDataFileSystem(std::array<u8, 0x40> save_create_struct,
+    Result CreateSaveDataFileSystem(FileSys::SaveDataCreationInfo save_create_struct,
                                     FileSys::SaveDataAttribute save_struct, u128 uid);
-    Result CreateSaveDataFileSystemBySystemSaveDataId(std::array<u8, 0x40> save_create_struct,
-                                                      FileSys::SaveDataAttribute save_struct);
+    Result CreateSaveDataFileSystemBySystemSaveDataId(
+        FileSys::SaveDataCreationInfo save_create_struct, FileSys::SaveDataAttribute save_struct);
     Result OpenSaveDataFileSystem(OutInterface<IFileSystem> out_interface,
                                   FileSys::SaveDataSpaceId space_id,
                                   FileSys::SaveDataAttribute attribute);
-- 
cgit v1.2.3


From b5a17b501bf66c02495ae6d69a6d734792e3cc6f Mon Sep 17 00:00:00 2001
From: FearlessTobi <thm.frey@gmail.com>
Date: Mon, 19 Feb 2024 15:43:18 +0100
Subject: Address review comments

---
 .../hle/service/filesystem/fsp/fs_i_filesystem.h   |  2 +-
 .../filesystem/fsp/fs_i_multi_commit_manager.cpp   |  3 +-
 .../filesystem/fsp/fs_i_multi_commit_manager.h     |  2 +-
 .../filesystem/fsp/fs_i_save_data_info_reader.h    |  4 +--
 src/core/hle/service/filesystem/fsp/fsp_srv.h      | 13 +--------
 src/core/hle/service/filesystem/fsp/fsp_types.h    | 34 ++++++++++++++++++++++
 src/core/hle/service/filesystem/fsp/fsp_util.h     | 22 --------------
 7 files changed, 41 insertions(+), 39 deletions(-)
 create mode 100644 src/core/hle/service/filesystem/fsp/fsp_types.h
 delete mode 100644 src/core/hle/service/filesystem/fsp/fsp_util.h

(limited to 'src/core/hle/service/filesystem/fsp')

diff --git a/src/core/hle/service/filesystem/fsp/fs_i_filesystem.h b/src/core/hle/service/filesystem/fsp/fs_i_filesystem.h
index b06b3ef0e..b1f3ab5dd 100644
--- a/src/core/hle/service/filesystem/fsp/fs_i_filesystem.h
+++ b/src/core/hle/service/filesystem/fsp/fs_i_filesystem.h
@@ -5,7 +5,7 @@
 
 #include "core/file_sys/vfs/vfs.h"
 #include "core/hle/service/filesystem/filesystem.h"
-#include "core/hle/service/filesystem/fsp/fsp_util.h"
+#include "core/hle/service/filesystem/fsp/fsp_types.h"
 #include "core/hle/service/service.h"
 
 namespace Service::FileSystem {
diff --git a/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.cpp b/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.cpp
index 13914b5e1..626328234 100644
--- a/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.cpp
+++ b/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.cpp
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/filesystem/fsp/fs_i_filesystem.h"
 #include "core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h"
 
 namespace Service::FileSystem {
@@ -17,7 +18,7 @@ IMultiCommitManager::IMultiCommitManager(Core::System& system_)
 
 IMultiCommitManager::~IMultiCommitManager() = default;
 
-Result IMultiCommitManager::Add() {
+Result IMultiCommitManager::Add(std::shared_ptr<IFileSystem> filesystem) {
     LOG_WARNING(Service_FS, "(STUBBED) called");
 
     R_SUCCEED();
diff --git a/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h b/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h
index 274ef0513..8ebf7c7d9 100644
--- a/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h
+++ b/src/core/hle/service/filesystem/fsp/fs_i_multi_commit_manager.h
@@ -14,7 +14,7 @@ public:
     ~IMultiCommitManager() override;
 
 private:
-    Result Add();
+    Result Add(std::shared_ptr<IFileSystem> filesystem);
     Result Commit();
 
     FileSys::VirtualFile backend;
diff --git a/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h b/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h
index 7b21b029b..e45ad852b 100644
--- a/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h
+++ b/src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h
@@ -23,14 +23,14 @@ public:
         u64_le save_id_unknown;
         FileSys::SaveDataSpaceId space;
         FileSys::SaveDataType type;
-        INSERT_PADDING_BYTES_NOINIT(0x6);
+        INSERT_PADDING_BYTES(0x6);
         std::array<u8, 0x10> user_id;
         u64_le save_id;
         u64_le title_id;
         u64_le save_image_size;
         u16_le index;
         FileSys::SaveDataRank rank;
-        INSERT_PADDING_BYTES_NOINIT(0x25);
+        INSERT_PADDING_BYTES(0x25);
     };
     static_assert(sizeof(SaveDataInfo) == 0x60, "SaveDataInfo has incorrect size.");
 
diff --git a/src/core/hle/service/filesystem/fsp/fsp_srv.h b/src/core/hle/service/filesystem/fsp/fsp_srv.h
index 7a29d17c9..ee67f6bc1 100644
--- a/src/core/hle/service/filesystem/fsp/fsp_srv.h
+++ b/src/core/hle/service/filesystem/fsp/fsp_srv.h
@@ -6,6 +6,7 @@
 #include <memory>
 #include "core/file_sys/fs_save_data_types.h"
 #include "core/hle/service/cmif_types.h"
+#include "core/hle/service/filesystem/fsp/fsp_types.h"
 #include "core/hle/service/service.h"
 
 namespace Core {
@@ -39,18 +40,6 @@ enum class AccessLogMode : u32 {
     SdCard,
 };
 
-enum class FileSystemProxyType : u8 {
-    Code = 0,
-    Rom = 1,
-    Logo = 2,
-    Control = 3,
-    Manual = 4,
-    Meta = 5,
-    Data = 6,
-    Package = 7,
-    RegisteredUpdate = 8,
-};
-
 class FSP_SRV final : public ServiceFramework<FSP_SRV> {
 public:
     explicit FSP_SRV(Core::System& system_);
diff --git a/src/core/hle/service/filesystem/fsp/fsp_types.h b/src/core/hle/service/filesystem/fsp/fsp_types.h
new file mode 100644
index 000000000..294da6a2d
--- /dev/null
+++ b/src/core/hle/service/filesystem/fsp/fsp_types.h
@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/filesystem/filesystem.h"
+
+namespace Service::FileSystem {
+
+enum class FileSystemProxyType : u8 {
+    Code = 0,
+    Rom = 1,
+    Logo = 2,
+    Control = 3,
+    Manual = 4,
+    Meta = 5,
+    Data = 6,
+    Package = 7,
+    RegisteredUpdate = 8,
+};
+
+struct SizeGetter {
+    std::function<u64()> get_free_size;
+    std::function<u64()> get_total_size;
+
+    static SizeGetter FromStorageId(const FileSystemController& fsc, FileSys::StorageId id) {
+        return {
+            [&fsc, id] { return fsc.GetFreeSpaceSize(id); },
+            [&fsc, id] { return fsc.GetTotalSpaceSize(id); },
+        };
+    }
+};
+
+} // namespace Service::FileSystem
diff --git a/src/core/hle/service/filesystem/fsp/fsp_util.h b/src/core/hle/service/filesystem/fsp/fsp_util.h
deleted file mode 100644
index 253f866db..000000000
--- a/src/core/hle/service/filesystem/fsp/fsp_util.h
+++ /dev/null
@@ -1,22 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/filesystem/filesystem.h"
-
-namespace Service::FileSystem {
-
-struct SizeGetter {
-    std::function<u64()> get_free_size;
-    std::function<u64()> get_total_size;
-
-    static SizeGetter FromStorageId(const FileSystemController& fsc, FileSys::StorageId id) {
-        return {
-            [&fsc, id] { return fsc.GetFreeSpaceSize(id); },
-            [&fsc, id] { return fsc.GetTotalSpaceSize(id); },
-        };
-    }
-};
-
-} // namespace Service::FileSystem
-- 
cgit v1.2.3