23 files changed, 271 insertions, 214 deletions

diff --git a/src/core/arm/arm_interface.h b/src/core/arm/arm_interface.h
index 32ff3c345..8416e73b0 100644
--- a/src/core/arm/arm_interface.h
+++ b/src/core/arm/arm_interface.h
@@ -116,6 +116,8 @@ public:
      */
     virtual void LoadContext(const ThreadContext& ctx) = 0;
 
+    virtual void ClearExclusiveState() = 0;
+
     /// Prepare core for thread reschedule (if needed to correctly handle state)
     virtual void PrepareReschedule() = 0;
 };
diff --git a/src/core/arm/dynarmic/arm_dynarmic.cpp b/src/core/arm/dynarmic/arm_dynarmic.cpp
index 42605374b..3572ee7b9 100644
--- a/src/core/arm/dynarmic/arm_dynarmic.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic.cpp
@@ -226,6 +226,10 @@ void ARM_Dynarmic::ClearInstructionCache() {
     jit->ClearCache();
 }
 
+void ARM_Dynarmic::ClearExclusiveState() {
+    jit->ClearExclusiveState();
+}
+
 void ARM_Dynarmic::PageTableChanged() {
     jit = MakeJit(cb);
     current_page_table = Memory::GetCurrentPageTable();
diff --git a/src/core/arm/dynarmic/arm_dynarmic.h b/src/core/arm/dynarmic/arm_dynarmic.h
index 128669d01..ed724c3f1 100644
--- a/src/core/arm/dynarmic/arm_dynarmic.h
+++ b/src/core/arm/dynarmic/arm_dynarmic.h
@@ -39,6 +39,7 @@ public:
     void LoadContext(const ThreadContext& ctx) override;
 
     void PrepareReschedule() override;
+    void ClearExclusiveState() override;
 
     void ClearInstructionCache() override;
     void PageTableChanged() override;
diff --git a/src/core/arm/unicorn/arm_unicorn.cpp b/src/core/arm/unicorn/arm_unicorn.cpp
index f239cf0ea..d2d699e9b 100644
--- a/src/core/arm/unicorn/arm_unicorn.cpp
+++ b/src/core/arm/unicorn/arm_unicorn.cpp
@@ -263,6 +263,8 @@ void ARM_Unicorn::PrepareReschedule() {
     CHECKED(uc_emu_stop(uc));
 }
 
+void ARM_Unicorn::ClearExclusiveState() {}
+
 void ARM_Unicorn::ClearInstructionCache() {}
 
 void ARM_Unicorn::RecordBreak(GDBStub::BreakpointAddress bkpt) {
diff --git a/src/core/arm/unicorn/arm_unicorn.h b/src/core/arm/unicorn/arm_unicorn.h
index a482a2aa3..a78a0acf2 100644
--- a/src/core/arm/unicorn/arm_unicorn.h
+++ b/src/core/arm/unicorn/arm_unicorn.h
@@ -31,6 +31,7 @@ public:
     void SaveContext(ThreadContext& ctx) override;
     void LoadContext(const ThreadContext& ctx) override;
     void PrepareReschedule() override;
+    void ClearExclusiveState() override;
     void ExecuteInstructions(int num_instructions);
     void Run() override;
     void Step() override;
diff --git a/src/core/file_sys/errors.h b/src/core/file_sys/errors.h
index d3e9a3829..1f3b8fa84 100644
--- a/src/core/file_sys/errors.h
+++ b/src/core/file_sys/errors.h
@@ -12,6 +12,8 @@ namespace ErrCodes {
 enum {
     NotFound = 1,
     SaveDataNotFound = 1002,
+    SdCardNotFound = 2001,
+    RomFSNotFound = 2520,
 };
 }
 
diff --git a/src/core/file_sys/filesystem.h b/src/core/file_sys/filesystem.h
index 295a3133e..1a32a373b 100644
--- a/src/core/file_sys/filesystem.h
+++ b/src/core/file_sys/filesystem.h
@@ -167,35 +167,4 @@ public:
     virtual ResultVal<EntryType> GetEntryType(const std::string& path) const = 0;
 };
 
-class FileSystemFactory : NonCopyable {
-public:
-    virtual ~FileSystemFactory() {}
-
-    /**
-     * Get a descriptive name for the archive (e.g. "RomFS", "SaveData", etc.)
-     */
-    virtual std::string GetName() const = 0;
-
-    /**
-     * Tries to open the archive of this type with the specified path
-     * @param path Path to the archive
-     * @return An ArchiveBackend corresponding operating specified archive path.
-     */
-    virtual ResultVal<std::unique_ptr<FileSystemBackend>> Open(const Path& path) = 0;
-
-    /**
-     * Deletes the archive contents and then re-creates the base folder
-     * @param path Path to the archive
-     * @return ResultCode of the operation, 0 on success
-     */
-    virtual ResultCode Format(const Path& path) = 0;
-
-    /**
-     * Retrieves the format info about the archive with the specified path
-     * @param path Path to the archive
-     * @return Format information about the archive or error code
-     */
-    virtual ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const = 0;
-};
-
 } // namespace FileSys
diff --git a/src/core/file_sys/romfs_factory.cpp b/src/core/file_sys/romfs_factory.cpp
index 84ae0d99b..946fc0452 100644
--- a/src/core/file_sys/romfs_factory.cpp
+++ b/src/core/file_sys/romfs_factory.cpp
@@ -11,28 +11,17 @@
 
 namespace FileSys {
 
-RomFS_Factory::RomFS_Factory(Loader::AppLoader& app_loader) {
+RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader) {
     // Load the RomFS from the app
     if (Loader::ResultStatus::Success != app_loader.ReadRomFS(romfs_file, data_offset, data_size)) {
         LOG_ERROR(Service_FS, "Unable to read RomFS!");
     }
 }
 
-ResultVal<std::unique_ptr<FileSystemBackend>> RomFS_Factory::Open(const Path& path) {
+ResultVal<std::unique_ptr<FileSystemBackend>> RomFSFactory::Open(u64 title_id) {
+    // TODO(DarkLordZach): Use title id.
     auto archive = std::make_unique<RomFS_FileSystem>(romfs_file, data_offset, data_size);
     return MakeResult<std::unique_ptr<FileSystemBackend>>(std::move(archive));
 }
 
-ResultCode RomFS_Factory::Format(const Path& path) {
-    LOG_ERROR(Service_FS, "Unimplemented Format archive {}", GetName());
-    // TODO(bunnei): Find the right error code for this
-    return ResultCode(-1);
-}
-
-ResultVal<ArchiveFormatInfo> RomFS_Factory::GetFormatInfo(const Path& path) const {
-    LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive {}", GetName());
-    // TODO(bunnei): Find the right error code for this
-    return ResultCode(-1);
-}
-
 } // namespace FileSys
diff --git a/src/core/file_sys/romfs_factory.h b/src/core/file_sys/romfs_factory.h
index e0698e642..c9e20c3ab 100644
--- a/src/core/file_sys/romfs_factory.h
+++ b/src/core/file_sys/romfs_factory.h
@@ -15,16 +15,11 @@
 namespace FileSys {
 
 /// File system interface to the RomFS archive
-class RomFS_Factory final : public FileSystemFactory {
+class RomFSFactory {
 public:
-    explicit RomFS_Factory(Loader::AppLoader& app_loader);
+    explicit RomFSFactory(Loader::AppLoader& app_loader);
 
-    std::string GetName() const override {
-        return "ArchiveFactory_RomFS";
-    }
-    ResultVal<std::unique_ptr<FileSystemBackend>> Open(const Path& path) override;
-    ResultCode Format(const Path& path) override;
-    ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const override;
+    ResultVal<std::unique_ptr<FileSystemBackend>> Open(u64 title_id);
 
 private:
     std::shared_ptr<FileUtil::IOFile> romfs_file;
diff --git a/src/core/file_sys/savedata_factory.cpp b/src/core/file_sys/savedata_factory.cpp
index f3aa213af..3ad37b28c 100644
--- a/src/core/file_sys/savedata_factory.cpp
+++ b/src/core/file_sys/savedata_factory.cpp
@@ -12,11 +12,49 @@
 
 namespace FileSys {
 
-SaveData_Factory::SaveData_Factory(std::string nand_directory)
+std::string SaveDataDescriptor::DebugInfo() {
+    return fmt::format("[type={:02X}, title_id={:016X}, user_id={:016X}{:016X}, save_id={:016X}]",
+                       static_cast<u8>(type), title_id, user_id[1], user_id[0], save_id);
+}
+
+SaveDataFactory::SaveDataFactory(std::string nand_directory)
     : nand_directory(std::move(nand_directory)) {}
 
-ResultVal<std::unique_ptr<FileSystemBackend>> SaveData_Factory::Open(const Path& path) {
-    std::string save_directory = GetFullPath();
+ResultVal<std::unique_ptr<FileSystemBackend>> SaveDataFactory::Open(SaveDataSpaceId space,
+                                                                    SaveDataDescriptor meta) {
+    if (meta.type == SaveDataType::SystemSaveData || meta.type == SaveDataType::SaveData) {
+        if (meta.zero_1 != 0) {
+            LOG_WARNING(Service_FS,
+                        "Possibly incorrect SaveDataDescriptor, type is "
+                        "SystemSaveData||SaveData but offset 0x28 is non-zero ({:016X}).",
+                        meta.zero_1);
+        }
+        if (meta.zero_2 != 0) {
+            LOG_WARNING(Service_FS,
+                        "Possibly incorrect SaveDataDescriptor, type is "
+                        "SystemSaveData||SaveData but offset 0x30 is non-zero ({:016X}).",
+                        meta.zero_2);
+        }
+        if (meta.zero_3 != 0) {
+            LOG_WARNING(Service_FS,
+                        "Possibly incorrect SaveDataDescriptor, type is "
+                        "SystemSaveData||SaveData but offset 0x38 is non-zero ({:016X}).",
+                        meta.zero_3);
+        }
+    }
+
+    if (meta.type == SaveDataType::SystemSaveData && meta.title_id != 0) {
+        LOG_WARNING(Service_FS,
+                    "Possibly incorrect SaveDataDescriptor, type is SystemSaveData but title_id is "
+                    "non-zero ({:016X}).",
+                    meta.title_id);
+    }
+
+    std::string save_directory =
+        GetFullPath(space, meta.type, meta.title_id, meta.user_id, meta.save_id);
+
+    // TODO(DarkLordZach): Try to not create when opening, there are dedicated create save methods.
+    // But, user_ids don't match so this works for now.
 
     if (!FileUtil::Exists(save_directory)) {
         // TODO(bunnei): This is a work-around to always create a save data directory if it does not
@@ -26,6 +64,12 @@ ResultVal<std::unique_ptr<FileSystemBackend>> SaveData_Factory::Open(const Path&
         FileUtil::CreateFullPath(save_directory);
     }
 
+    // TODO(DarkLordZach): For some reason, CreateFullPath doesn't create the last bit. Should be
+    // fixed with VFS.
+    if (!FileUtil::IsDirectory(save_directory)) {
+        FileUtil::CreateDir(save_directory);
+    }
+
     // Return an error if the save data doesn't actually exist.
     if (!FileUtil::IsDirectory(save_directory)) {
         // TODO(Subv): Find out correct error code.
@@ -36,28 +80,35 @@ ResultVal<std::unique_ptr<FileSystemBackend>> SaveData_Factory::Open(const Path&
     return MakeResult<std::unique_ptr<FileSystemBackend>>(std::move(archive));
 }
 
-ResultCode SaveData_Factory::Format(const Path& path) {
-    LOG_WARNING(Service_FS, "Format archive {}", GetName());
-    // Create the save data directory.
-    if (!FileUtil::CreateFullPath(GetFullPath())) {
-        // TODO(Subv): Find the correct error code.
-        return ResultCode(-1);
-    }
+std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id,
+                                         u128 user_id, u64 save_id) const {
+    // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
+    // be interpreted as the title id of the current process.
+    if (type == SaveDataType::SaveData && title_id == 0)
+        title_id = Core::CurrentProcess()->program_id;
 
-    return RESULT_SUCCESS;
-}
+    std::string prefix;
 
-ResultVal<ArchiveFormatInfo> SaveData_Factory::GetFormatInfo(const Path& path) const {
-    LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive {}", GetName());
-    // TODO(bunnei): Find the right error code for this
-    return ResultCode(-1);
-}
+    switch (space) {
+    case SaveDataSpaceId::NandSystem:
+        prefix = nand_directory + "system/save/";
+        break;
+    case SaveDataSpaceId::NandUser:
+        prefix = nand_directory + "user/save/";
+        break;
+    default:
+        ASSERT_MSG(false, "Unrecognized SaveDataSpaceId: {:02X}", static_cast<u8>(space));
+    }
 
-std::string SaveData_Factory::GetFullPath() const {
-    u64 title_id = Core::CurrentProcess()->program_id;
-    // TODO(Subv): Somehow obtain this value.
-    u32 user = 0;
-    return fmt::format("{}save/{:016X}/{:08X}/", nand_directory, title_id, user);
+    switch (type) {
+    case SaveDataType::SystemSaveData:
+        return fmt::format("{}{:016X}/{:016X}{:016X}", prefix, save_id, user_id[1], user_id[0]);
+    case SaveDataType::SaveData:
+        return fmt::format("{}{:016X}/{:016X}{:016X}/{:016X}", prefix, 0, user_id[1], user_id[0],
+                           title_id);
+    default:
+        ASSERT_MSG(false, "Unrecognized SaveDataType: {:02X}", static_cast<u8>(type));
+    }
 }
 
 } // namespace FileSys
diff --git a/src/core/file_sys/savedata_factory.h b/src/core/file_sys/savedata_factory.h
index 73a42aab6..b96721ac0 100644
--- a/src/core/file_sys/savedata_factory.h
+++ b/src/core/file_sys/savedata_factory.h
@@ -12,22 +12,50 @@
 
 namespace FileSys {
 
+enum class SaveDataSpaceId : u8 {
+    NandSystem = 0,
+    NandUser = 1,
+    SdCard = 2,
+    TemporaryStorage = 3,
+};
+
+enum class SaveDataType : u8 {
+    SystemSaveData = 0,
+    SaveData = 1,
+    BcatDeliveryCacheStorage = 2,
+    DeviceSaveData = 3,
+    TemporaryStorage = 4,
+    CacheStorage = 5,
+};
+
+struct SaveDataDescriptor {
+    u64_le title_id;
+    u128 user_id;
+    u64_le save_id;
+    SaveDataType type;
+    INSERT_PADDING_BYTES(7);
+    u64_le zero_1;
+    u64_le zero_2;
+    u64_le zero_3;
+
+    std::string DebugInfo();
+};
+static_assert(sizeof(SaveDataDescriptor) == 0x40, "SaveDataDescriptor has incorrect size.");
+
 /// File system interface to the SaveData archive
-class SaveData_Factory final : public FileSystemFactory {
+class SaveDataFactory {
 public:
-    explicit SaveData_Factory(std::string nand_directory);
+    explicit SaveDataFactory(std::string nand_directory);
 
-    std::string GetName() const override {
-        return "SaveData_Factory";
-    }
-    ResultVal<std::unique_ptr<FileSystemBackend>> Open(const Path& path) override;
-    ResultCode Format(const Path& path) override;
-    ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const override;
+    ResultVal<std::unique_ptr<FileSystemBackend>> Open(SaveDataSpaceId space,
+                                                       SaveDataDescriptor meta);
 
 private:
     std::string nand_directory;
+    std::string sd_directory;
 
-    std::string GetFullPath() const;
+    std::string GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id,
+                            u64 save_id) const;
 };
 
 } // namespace FileSys
diff --git a/src/core/file_sys/sdmc_factory.cpp b/src/core/file_sys/sdmc_factory.cpp
index 2e5ffb764..ac6f2f971 100644
--- a/src/core/file_sys/sdmc_factory.cpp
+++ b/src/core/file_sys/sdmc_factory.cpp
@@ -12,9 +12,9 @@
 
 namespace FileSys {
 
-SDMC_Factory::SDMC_Factory(std::string sd_directory) : sd_directory(std::move(sd_directory)) {}
+SDMCFactory::SDMCFactory(std::string sd_directory) : sd_directory(std::move(sd_directory)) {}
 
-ResultVal<std::unique_ptr<FileSystemBackend>> SDMC_Factory::Open(const Path& path) {
+ResultVal<std::unique_ptr<FileSystemBackend>> SDMCFactory::Open() {
     // Create the SD Card directory if it doesn't already exist.
     if (!FileUtil::IsDirectory(sd_directory)) {
         FileUtil::CreateFullPath(sd_directory);
@@ -24,16 +24,4 @@ ResultVal<std::unique_ptr<FileSystemBackend>> SDMC_Factory::Open(const Path& pat
     return MakeResult<std::unique_ptr<FileSystemBackend>>(std::move(archive));
 }
 
-ResultCode SDMC_Factory::Format(const Path& path) {
-    LOG_ERROR(Service_FS, "Unimplemented Format archive {}", GetName());
-    // TODO(Subv): Find the right error code for this
-    return ResultCode(-1);
-}
-
-ResultVal<ArchiveFormatInfo> SDMC_Factory::GetFormatInfo(const Path& path) const {
-    LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive {}", GetName());
-    // TODO(bunnei): Find the right error code for this
-    return ResultCode(-1);
-}
-
 } // namespace FileSys
diff --git a/src/core/file_sys/sdmc_factory.h b/src/core/file_sys/sdmc_factory.h
index 93becda25..09bec7fce 100644
--- a/src/core/file_sys/sdmc_factory.h
+++ b/src/core/file_sys/sdmc_factory.h
@@ -13,16 +13,11 @@
 namespace FileSys {
 
 /// File system interface to the SDCard archive
-class SDMC_Factory final : public FileSystemFactory {
+class SDMCFactory {
 public:
-    explicit SDMC_Factory(std::string sd_directory);
+    explicit SDMCFactory(std::string sd_directory);
 
-    std::string GetName() const override {
-        return "SDMC_Factory";
-    }
-    ResultVal<std::unique_ptr<FileSystemBackend>> Open(const Path& path) override;
-    ResultCode Format(const Path& path) override;
-    ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const override;
+    ResultVal<std::unique_ptr<FileSystemBackend>> Open();
 
 private:
     std::string sd_directory;
diff --git a/src/core/hle/kernel/address_arbiter.cpp b/src/core/hle/kernel/address_arbiter.cpp
index e9c8369d7..d5df9590a 100644
--- a/src/core/hle/kernel/address_arbiter.cpp
+++ b/src/core/hle/kernel/address_arbiter.cpp
@@ -115,7 +115,7 @@ ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 valu
     s32 updated_value;
     if (waiting_threads.size() == 0) {
         updated_value = value - 1;
-    } else if (num_to_wake <= 0 || waiting_threads.size() <= num_to_wake) {
+    } else if (num_to_wake <= 0 || waiting_threads.size() <= static_cast<u32>(num_to_wake)) {
         updated_value = value + 1;
     } else {
         updated_value = value;
@@ -140,7 +140,9 @@ ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout, bool
 
     s32 cur_value = static_cast<s32>(Memory::Read32(address));
     if (cur_value < value) {
-        Memory::Write32(address, static_cast<u32>(cur_value - 1));
+        if (should_decrement) {
+            Memory::Write32(address, static_cast<u32>(cur_value - 1));
+        }
     } else {
         return ERR_INVALID_STATE;
     }
diff --git a/src/core/hle/kernel/scheduler.cpp b/src/core/hle/kernel/scheduler.cpp
index 11c2cb69e..ca8807e19 100644
--- a/src/core/hle/kernel/scheduler.cpp
+++ b/src/core/hle/kernel/scheduler.cpp
@@ -85,6 +85,7 @@ void Scheduler::SwitchContext(Thread* new_thread) {
 
         cpu_core->LoadContext(new_thread->context);
         cpu_core->SetTlsAddress(new_thread->GetTLSAddress());
+        cpu_core->ClearExclusiveState();
     } else {
         current_thread = nullptr;
         // Note: We do not reset the current process and current page table when idling because
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index a871b3eaa..0f0ab1e6a 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -4,9 +4,11 @@
 
 #include <cinttypes>
 #include <stack>
+#include "core/core.h"
 #include "core/file_sys/filesystem.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
+#include "core/hle/kernel/process.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/am/applet_oe.h"
@@ -614,25 +616,14 @@ void IApplicationFunctions::CreateApplicationAndRequestToStartForQuest(
 
 void IApplicationFunctions::EnsureSaveData(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    u128 uid = rp.PopRaw<u128>();
+    u128 uid = rp.PopRaw<u128>(); // What does this do?
 
     LOG_WARNING(Service, "(STUBBED) called uid = {:016X}{:016X}", uid[1], uid[0]);
 
     IPC::ResponseBuilder rb{ctx, 4};
-
-    FileSys::Path unused;
-    auto savedata = FileSystem::OpenFileSystem(FileSystem::Type::SaveData, unused);
-    if (savedata.Failed()) {
-        // Create the save data and return an error indicating that the operation was performed.
-        FileSystem::FormatFileSystem(FileSystem::Type::SaveData);
-        // TODO(Subv): Find out the correct error code for this.
-        rb.Push(ResultCode(ErrorModule::FS, 40));
-    } else {
-        rb.Push(RESULT_SUCCESS);
-    }
-
+    rb.Push(RESULT_SUCCESS);
     rb.Push<u64>(0);
-}
+} // namespace Service::AM
 
 void IApplicationFunctions::SetTerminateResult(Kernel::HLERequestContext& ctx) {
     // Takes an input u32 Result, no output.
diff --git a/src/core/hle/service/filesystem/filesystem.cpp b/src/core/hle/service/filesystem/filesystem.cpp
index f58b518b6..902256757 100644
--- a/src/core/hle/service/filesystem/filesystem.cpp
+++ b/src/core/hle/service/filesystem/filesystem.cpp
@@ -4,6 +4,7 @@
 
 #include <boost/container/flat_map.hpp>
 #include "common/file_util.h"
+#include "core/file_sys/errors.h"
 #include "core/file_sys/filesystem.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/sdmc_factory.h"
@@ -16,57 +17,77 @@ namespace Service::FileSystem {
  * Map of registered file systems, identified by type. Once an file system is registered here, it
  * is never removed until UnregisterFileSystems is called.
  */
-static boost::container::flat_map<Type, std::unique_ptr<FileSys::FileSystemFactory>> filesystem_map;
-
-ResultCode RegisterFileSystem(std::unique_ptr<FileSys::FileSystemFactory>&& factory, Type type) {
-    auto result = filesystem_map.emplace(type, std::move(factory));
+static std::unique_ptr<FileSys::RomFSFactory> romfs_factory;
+static std::unique_ptr<FileSys::SaveDataFactory> save_data_factory;
+static std::unique_ptr<FileSys::SDMCFactory> sdmc_factory;
+
+ResultCode RegisterRomFS(std::unique_ptr<FileSys::RomFSFactory>&& factory) {
+    ASSERT_MSG(romfs_factory == nullptr, "Tried to register a second RomFS");
+    romfs_factory = std::move(factory);
+    LOG_DEBUG(Service_FS, "Registered RomFS");
+    return RESULT_SUCCESS;
+}
 
-    bool inserted = result.second;
-    ASSERT_MSG(inserted, "Tried to register more than one system with same id code");
+ResultCode RegisterSaveData(std::unique_ptr<FileSys::SaveDataFactory>&& factory) {
+    ASSERT_MSG(romfs_factory == nullptr, "Tried to register a second save data");
+    save_data_factory = std::move(factory);
+    LOG_DEBUG(Service_FS, "Registered save data");
+    return RESULT_SUCCESS;
+}
 
-    auto& filesystem = result.first->second;
-    LOG_DEBUG(Service_FS, "Registered file system {} with id code 0x{:08X}", filesystem->GetName(),
-              static_cast<u32>(type));
+ResultCode RegisterSDMC(std::unique_ptr<FileSys::SDMCFactory>&& factory) {
+    ASSERT_MSG(sdmc_factory == nullptr, "Tried to register a second SDMC");
+    sdmc_factory = std::move(factory);
+    LOG_DEBUG(Service_FS, "Registered SDMC");
     return RESULT_SUCCESS;
 }
 
-ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenFileSystem(Type type,
-                                                                      FileSys::Path& path) {
-    LOG_TRACE(Service_FS, "Opening FileSystem with type={}", static_cast<u32>(type));
+ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenRomFS(u64 title_id) {
+    LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}", title_id);
 
-    auto itr = filesystem_map.find(type);
-    if (itr == filesystem_map.end()) {
+    if (romfs_factory == nullptr) {
         // TODO(bunnei): Find a better error code for this
         return ResultCode(-1);
     }
 
-    return itr->second->Open(path);
+    return romfs_factory->Open(title_id);
 }
 
-ResultCode FormatFileSystem(Type type) {
-    LOG_TRACE(Service_FS, "Formatting FileSystem with type={}", static_cast<u32>(type));
+ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenSaveData(
+    FileSys::SaveDataSpaceId space, FileSys::SaveDataDescriptor save_struct) {
+    LOG_TRACE(Service_FS, "Opening Save Data for space_id={:01X}, save_struct={}",
+              static_cast<u8>(space), SaveStructDebugInfo(save_struct));
 
-    auto itr = filesystem_map.find(type);
-    if (itr == filesystem_map.end()) {
-        // TODO(bunnei): Find a better error code for this
-        return ResultCode(-1);
+    if (save_data_factory == nullptr) {
+        return ResultCode(ErrorModule::FS, FileSys::ErrCodes::SaveDataNotFound);
+    }
+
+    return save_data_factory->Open(space, save_struct);
+}
+
+ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenSDMC() {
+    LOG_TRACE(Service_FS, "Opening SDMC");
+
+    if (sdmc_factory == nullptr) {
+        return ResultCode(ErrorModule::FS, FileSys::ErrCodes::SdCardNotFound);
     }
 
-    FileSys::Path unused;
-    return itr->second->Format(unused);
+    return sdmc_factory->Open();
 }
 
 void RegisterFileSystems() {
-    filesystem_map.clear();
+    romfs_factory = nullptr;
+    save_data_factory = nullptr;
+    sdmc_factory = nullptr;
 
     std::string nand_directory = FileUtil::GetUserPath(D_NAND_IDX);
     std::string sd_directory = FileUtil::GetUserPath(D_SDMC_IDX);
 
-    auto savedata = std::make_unique<FileSys::SaveData_Factory>(std::move(nand_directory));
-    RegisterFileSystem(std::move(savedata), Type::SaveData);
+    auto savedata = std::make_unique<FileSys::SaveDataFactory>(std::move(nand_directory));
+    save_data_factory = std::move(savedata);
 
-    auto sdcard = std::make_unique<FileSys::SDMC_Factory>(std::move(sd_directory));
-    RegisterFileSystem(std::move(sdcard), Type::SDMC);
+    auto sdcard = std::make_unique<FileSys::SDMCFactory>(std::move(sd_directory));
+    sdmc_factory = std::move(sdcard);
 }
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
diff --git a/src/core/hle/service/filesystem/filesystem.h b/src/core/hle/service/filesystem/filesystem.h
index 56d26146e..45272d326 100644
--- a/src/core/hle/service/filesystem/filesystem.h
+++ b/src/core/hle/service/filesystem/filesystem.h
@@ -6,12 +6,13 @@
 
 #include <memory>
 #include "common/common_types.h"
+#include "core/file_sys/romfs_factory.h"
+#include "core/file_sys/savedata_factory.h"
+#include "core/file_sys/sdmc_factory.h"
 #include "core/hle/result.h"
 
 namespace FileSys {
 class FileSystemBackend;
-class FileSystemFactory;
-class Path;
 } // namespace FileSys
 
 namespace Service {
@@ -22,35 +23,20 @@ class ServiceManager;
 
 namespace FileSystem {
 
-/// Supported FileSystem types
-enum class Type {
-    RomFS = 1,
-    SaveData = 2,
-    SDMC = 3,
-};
-
-/**
- * Registers a FileSystem, instances of which can later be opened using its IdCode.
- * @param factory FileSystem backend interface to use
- * @param type Type used to access this type of FileSystem
- */
-ResultCode RegisterFileSystem(std::unique_ptr<FileSys::FileSystemFactory>&& factory, Type type);
-
-/**
- * Opens a file system
- * @param type Type of the file system to open
- * @param path Path to the file system, used with Binary paths
- * @return FileSys::FileSystemBackend interface to the file system
- */
-ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenFileSystem(Type type,
-                                                                      FileSys::Path& path);
-
-/**
- * Formats a file system
- * @param type Type of the file system to format
- * @return ResultCode of the operation
- */
-ResultCode FormatFileSystem(Type type);
+ResultCode RegisterRomFS(std::unique_ptr<FileSys::RomFSFactory>&& factory);
+ResultCode RegisterSaveData(std::unique_ptr<FileSys::SaveDataFactory>&& factory);
+ResultCode RegisterSDMC(std::unique_ptr<FileSys::SDMCFactory>&& factory);
+
+// TODO(DarkLordZach): BIS Filesystem
+// ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory);
+
+ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenRomFS(u64 title_id);
+ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenSaveData(
+    FileSys::SaveDataSpaceId space, FileSys::SaveDataDescriptor save_struct);
+ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenSDMC();
+
+// TODO(DarkLordZach): BIS Filesystem
+// ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenBIS();
 
 /// Registers all Filesystem services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
diff --git a/src/core/hle/service/filesystem/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp_srv.cpp
index 82efe7f7d..22d3e645d 100644
--- a/src/core/hle/service/filesystem/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp_srv.cpp
@@ -13,11 +13,21 @@
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
+#include "core/hle/kernel/process.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/filesystem/fsp_srv.h"
 
 namespace Service::FileSystem {
 
+enum class StorageId : u8 {
+    None = 0,
+    Host = 1,
+    GameCard = 2,
+    NandSystem = 3,
+    NandUser = 4,
+    SdCard = 5
+};
+
 class IStorage final : public ServiceFramework<IStorage> {
 public:
     IStorage(std::unique_ptr<FileSys::StorageBackend>&& backend)
@@ -487,17 +497,6 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
     RegisterHandlers(functions);
 }
 
-void FSP_SRV::TryLoadRomFS() {
-    if (romfs) {
-        return;
-    }
-    FileSys::Path unused;
-    auto res = OpenFileSystem(Type::RomFS, unused);
-    if (res.Succeeded()) {
-        romfs = std::move(res.Unwrap());
-    }
-}
-
 void FSP_SRV::Initialize(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_FS, "(STUBBED) called");
 
@@ -508,8 +507,7 @@ void FSP_SRV::Initialize(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::MountSdCard(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_FS, "called");
 
-    FileSys::Path unused;
-    auto filesystem = OpenFileSystem(Type::SDMC, unused).Unwrap();
+    IFileSystem filesystem(OpenSDMC().Unwrap());
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
@@ -519,23 +517,26 @@ void FSP_SRV::MountSdCard(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::CreateSaveData(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
-    auto save_struct = rp.PopRaw<std::array<u8, 0x40>>();
+    auto save_struct = rp.PopRaw<FileSys::SaveDataDescriptor>();
     auto save_create_struct = rp.PopRaw<std::array<u8, 0x40>>();
     u128 uid = rp.PopRaw<u128>();
 
-    LOG_WARNING(Service_FS, "(STUBBED) called uid = {:016X}{:016X}", uid[1], uid[0]);
+    LOG_WARNING(Service_FS, "(STUBBED) called save_struct = {}, uid = {:016X}{:016X}",
+                save_struct.DebugInfo(), uid[1], uid[0]);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }
 
 void FSP_SRV::MountSaveData(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
+    IPC::RequestParser rp{ctx};
+
+    auto space_id = rp.PopRaw<FileSys::SaveDataSpaceId>();
+    auto unk = rp.Pop<u32>();
+    LOG_INFO(Service_FS, "called with unknown={:08X}", unk);
+    auto save_struct = rp.PopRaw<FileSys::SaveDataDescriptor>();
 
-    // TODO(Subv): Read the input parameters and mount the requested savedata instead of always
-    // mounting the current process' savedata.
-    FileSys::Path unused;
-    auto filesystem = OpenFileSystem(Type::SaveData, unused);
+    auto filesystem = OpenSaveData(space_id, save_struct);
 
     if (filesystem.Failed()) {
         IPC::ResponseBuilder rb{ctx, 2, 0, 0};
@@ -559,8 +560,8 @@ void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_FS, "called");
 
-    TryLoadRomFS();
-    if (!romfs) {
+    auto romfs = OpenRomFS(Core::System::GetInstance().CurrentProcess()->program_id);
+    if (romfs.Failed()) {
         // TODO (bunnei): Find the right error code to use here
         LOG_CRITICAL(Service_FS, "no file system interface available!");
         IPC::ResponseBuilder rb{ctx, 2};
@@ -568,8 +569,8 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
         return;
     }
 
-    // Attempt to open a StorageBackend interface to the RomFS
-    auto storage = romfs->OpenFile({}, {});
+    auto storage = romfs.Unwrap()->OpenFile({}, {});
+
     if (storage.Failed()) {
         LOG_CRITICAL(Service_FS, "no storage interface available!");
         IPC::ResponseBuilder rb{ctx, 2};
@@ -583,8 +584,40 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
 }
 
 void FSP_SRV::OpenRomStorage(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_FS, "(STUBBED) called, using OpenDataStorageByCurrentProcess");
-    OpenDataStorageByCurrentProcess(ctx);
+    IPC::RequestParser rp{ctx};
+
+    auto storage_id = rp.PopRaw<StorageId>();
+    auto title_id = rp.PopRaw<u64>();
+
+    LOG_DEBUG(Service_FS, "called with storage_id={:02X}, title_id={:016X}",
+              static_cast<u8>(storage_id), title_id);
+    if (title_id != Core::System::GetInstance().CurrentProcess()->program_id) {
+        LOG_CRITICAL(
+            Service_FS,
+            "Attempting to access RomFS of another title id (current={:016X}, requested={:016X}).",
+            Core::System::GetInstance().CurrentProcess()->program_id, title_id);
+    }
+
+    auto romfs = OpenRomFS(title_id);
+    if (romfs.Failed()) {
+        LOG_CRITICAL(Service_FS, "no file system interface available!");
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultCode(ErrorModule::FS, FileSys::ErrCodes::RomFSNotFound));
+        return;
+    }
+
+    auto storage = romfs.Unwrap()->OpenFile({}, {});
+
+    if (storage.Failed()) {
+        LOG_CRITICAL(Service_FS, "no storage interface available!");
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(storage.Code());
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IStorage>(std::move(storage.Unwrap()));
 }
 
 } // namespace Service::FileSystem
diff --git a/src/core/hle/service/filesystem/fsp_srv.h b/src/core/hle/service/filesystem/fsp_srv.h
index acb78fac1..4653eee4e 100644
--- a/src/core/hle/service/filesystem/fsp_srv.h
+++ b/src/core/hle/service/filesystem/fsp_srv.h
@@ -19,8 +19,6 @@ public:
     ~FSP_SRV() = default;
 
 private:
-    void TryLoadRomFS();
-
     void Initialize(Kernel::HLERequestContext& ctx);
     void MountSdCard(Kernel::HLERequestContext& ctx);
     void CreateSaveData(Kernel::HLERequestContext& ctx);
diff --git a/src/core/loader/deconstructed_rom_directory.cpp b/src/core/loader/deconstructed_rom_directory.cpp
index 5fdb1d289..0b11bf4f3 100644
--- a/src/core/loader/deconstructed_rom_directory.cpp
+++ b/src/core/loader/deconstructed_rom_directory.cpp
@@ -154,8 +154,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
 
     // Register the RomFS if a ".romfs" file was found
     if (!filepath_romfs.empty()) {
-        Service::FileSystem::RegisterFileSystem(std::make_unique<FileSys::RomFS_Factory>(*this),
-                                                Service::FileSystem::Type::RomFS);
+        Service::FileSystem::RegisterRomFS(std::make_unique<FileSys::RomFSFactory>(*this));
     }
 
     is_loaded = true;
diff --git a/src/core/loader/nca.cpp b/src/core/loader/nca.cpp
index 0fd930ae2..b463f369c 100644
--- a/src/core/loader/nca.cpp
+++ b/src/core/loader/nca.cpp
@@ -277,8 +277,7 @@ ResultStatus AppLoader_NCA::Load(Kernel::SharedPtr<Kernel::Process>& process) {
                  metadata.GetMainThreadStackSize());
 
     if (nca->GetRomFsSize() > 0)
-        Service::FileSystem::RegisterFileSystem(std::make_unique<FileSys::RomFS_Factory>(*this),
-                                                Service::FileSystem::Type::RomFS);
+        Service::FileSystem::RegisterRomFS(std::make_unique<FileSys::RomFSFactory>(*this));
 
     is_loaded = true;
     return ResultStatus::Success;
diff --git a/src/core/loader/nso.cpp b/src/core/loader/nso.cpp
index 1c629e21f..7b3d6b837 100644
--- a/src/core/loader/nso.cpp
+++ b/src/core/loader/nso.cpp
@@ -115,7 +115,7 @@ VAddr AppLoader_NSO::LoadModule(const std::string& name, const std::vector<u8>&
     std::vector<u8> program_image;
     for (int i = 0; i < nso_header.segments.size(); ++i) {
         std::vector<u8> compressed_data(nso_header.segments_compressed_size[i]);
-        for (int j = 0; j < nso_header.segments_compressed_size[i]; ++j)
+        for (auto j = 0; j < nso_header.segments_compressed_size[i]; ++j)
             compressed_data[j] = file_data[nso_header.segments[i].offset + j];
         std::vector<u8> data = DecompressSegment(compressed_data, nso_header.segments[i]);
         program_image.resize(nso_header.segments[i].location);