2 files changed, 203 insertions, 263 deletions

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;