Merge pull request #4662 from lioncash/factory

bis_factory/romfs_factory: Eliminate dependencies on the global system instance

src/core/core.cpp

@@ -629,11 +629,11 @@ Loader::AppLoader& System::GetAppLoader() const {
     return *impl->app_loader;
 }
 
-void System::SetFilesystem(std::shared_ptr<FileSys::VfsFilesystem> vfs) {
+void System::SetFilesystem(FileSys::VirtualFilesystem vfs) {
     impl->virtual_filesystem = std::move(vfs);
 }
 
-std::shared_ptr<FileSys::VfsFilesystem> System::GetFilesystem() const {
+FileSys::VirtualFilesystem System::GetFilesystem() const {
     return impl->virtual_filesystem;
 }
 

src/core/core.h

@@ -316,9 +316,9 @@ public:
     Service::SM::ServiceManager& ServiceManager();
     const Service::SM::ServiceManager& ServiceManager() const;
 
-    void SetFilesystem(std::shared_ptr<FileSys::VfsFilesystem> vfs);
+    void SetFilesystem(FileSys::VirtualFilesystem vfs);
 
-    std::shared_ptr<FileSys::VfsFilesystem> GetFilesystem() const;
+    FileSys::VirtualFilesystem GetFilesystem() const;
 
     void RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
                            const std::array<u8, 0x20>& build_id, VAddr main_region_begin,

src/core/file_sys/bis_factory.cpp

@@ -4,10 +4,10 @@
 
 #include <fmt/format.h>
 #include "common/file_util.h"
-#include "core/core.h"
 #include "core/file_sys/bis_factory.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/registered_cache.h"
+#include "core/file_sys/vfs.h"
 
 namespace FileSys {
 
@@ -81,11 +81,11 @@ VirtualDir BISFactory::OpenPartition(BisPartitionId id) const {
     }
 }
 
-VirtualFile BISFactory::OpenPartitionStorage(BisPartitionId id) const {
+VirtualFile BISFactory::OpenPartitionStorage(BisPartitionId id,
+                                             VirtualFilesystem file_system) const {
     auto& keys = Core::Crypto::KeyManager::Instance();
-    Core::Crypto::PartitionDataManager pdm{
-        Core::System::GetInstance().GetFilesystem()->OpenDirectory(
-            Common::FS::GetUserPath(Common::FS::UserPath::SysDataDir), Mode::Read)};
+    Core::Crypto::PartitionDataManager pdm{file_system->OpenDirectory(
+        Common::FS::GetUserPath(Common::FS::UserPath::SysDataDir), Mode::Read)};
     keys.PopulateFromPartitionData(pdm);
 
     switch (id) {

src/core/file_sys/bis_factory.h

@@ -52,7 +52,7 @@ public:
     VirtualDir GetModificationDumpRoot(u64 title_id) const;
 
     VirtualDir OpenPartition(BisPartitionId id) const;
-    VirtualFile OpenPartitionStorage(BisPartitionId id) const;
+    VirtualFile OpenPartitionStorage(BisPartitionId id, VirtualFilesystem file_system) const;
 
     VirtualDir GetImageDirectory() const;
 

src/core/file_sys/romfs_factory.cpp

@@ -6,7 +6,6 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
@@ -19,7 +18,9 @@
 
 namespace FileSys {
 
-RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader) {
+RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader, ContentProvider& provider,
+                           Service::FileSystem::FileSystemController& controller)
+    : content_provider{provider}, filesystem_controller{controller} {
     // Load the RomFS from the app
     if (app_loader.ReadRomFS(file) != Loader::ResultStatus::Success) {
         LOG_ERROR(Service_FS, "Unable to read RomFS!");
@@ -46,39 +47,38 @@ ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_titl
 
 ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
                                           ContentRecordType type) const {
-    std::shared_ptr<NCA> res;
-
-    switch (storage) {
-    case StorageId::None:
-        res = Core::System::GetInstance().GetContentProvider().GetEntry(title_id, type);
-        break;
-    case StorageId::NandSystem:
-        res =
-            Core::System::GetInstance().GetFileSystemController().GetSystemNANDContents()->GetEntry(
-                title_id, type);
-        break;
-    case StorageId::NandUser:
-        res = Core::System::GetInstance().GetFileSystemController().GetUserNANDContents()->GetEntry(
-            title_id, type);
-        break;
-    case StorageId::SdCard:
-        res = Core::System::GetInstance().GetFileSystemController().GetSDMCContents()->GetEntry(
-            title_id, type);
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented storage_id={:02X}", static_cast<u8>(storage));
-    }
-
+    const std::shared_ptr<NCA> res = GetEntry(title_id, storage, type);
     if (res == nullptr) {
         // TODO(DarkLordZach): Find the right error code to use here
         return RESULT_UNKNOWN;
     }
+
     const auto romfs = res->GetRomFS();
     if (romfs == nullptr) {
         // TODO(DarkLordZach): Find the right error code to use here
         return RESULT_UNKNOWN;
     }
+
     return MakeResult<VirtualFile>(romfs);
 }
 
+std::shared_ptr<NCA> RomFSFactory::GetEntry(u64 title_id, StorageId storage,
+                                            ContentRecordType type) const {
+    switch (storage) {
+    case StorageId::None:
+        return content_provider.GetEntry(title_id, type);
+    case StorageId::NandSystem:
+        return filesystem_controller.GetSystemNANDContents()->GetEntry(title_id, type);
+    case StorageId::NandUser:
+        return filesystem_controller.GetUserNANDContents()->GetEntry(title_id, type);
+    case StorageId::SdCard:
+        return filesystem_controller.GetSDMCContents()->GetEntry(title_id, type);
+    case StorageId::Host:
+    case StorageId::GameCard:
+    default:
+        UNIMPLEMENTED_MSG("Unimplemented storage_id={:02X}", static_cast<u8>(storage));
+        return nullptr;
+    }
+}
+
 } // namespace FileSys

src/core/file_sys/romfs_factory.h

@@ -13,8 +13,15 @@ namespace Loader {
 class AppLoader;
 } // namespace Loader
 
+namespace Service::FileSystem {
+class FileSystemController;
+}
+
 namespace FileSys {
 
+class ContentProvider;
+class NCA;
+
 enum class ContentRecordType : u8;
 
 enum class StorageId : u8 {
@@ -29,18 +36,26 @@ enum class StorageId : u8 {
 /// File system interface to the RomFS archive
 class RomFSFactory {
 public:
-    explicit RomFSFactory(Loader::AppLoader& app_loader);
+    explicit RomFSFactory(Loader::AppLoader& app_loader, ContentProvider& provider,
+                          Service::FileSystem::FileSystemController& controller);
     ~RomFSFactory();
 
     void SetPackedUpdate(VirtualFile update_raw);
-    ResultVal<VirtualFile> OpenCurrentProcess(u64 current_process_title_id) const;
-    ResultVal<VirtualFile> Open(u64 title_id, StorageId storage, ContentRecordType type) const;
+    [[nodiscard]] ResultVal<VirtualFile> OpenCurrentProcess(u64 current_process_title_id) const;
+    [[nodiscard]] ResultVal<VirtualFile> Open(u64 title_id, StorageId storage,
+                                              ContentRecordType type) const;
 
 private:
+    [[nodiscard]] std::shared_ptr<NCA> GetEntry(u64 title_id, StorageId storage,
+                                                ContentRecordType type) const;
+
     VirtualFile file;
     VirtualFile update_raw;
     bool updatable;
     u64 ivfc_offset;
+
+    ContentProvider& content_provider;
+    Service::FileSystem::FileSystemController& filesystem_controller;
 };
 
 } // namespace FileSys

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

@@ -379,7 +379,7 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenBISPartitionStorage(
         return FileSys::ERROR_ENTITY_NOT_FOUND;
     }
 
-    auto part = bis_factory->OpenPartitionStorage(id);
+    auto part = bis_factory->OpenPartitionStorage(id, system.GetFilesystem());
     if (part == nullptr) {
         return FileSys::ERROR_INVALID_ARGUMENT;
     }

src/core/loader/deconstructed_rom_directory.cpp

@@ -192,8 +192,8 @@ AppLoader_DeconstructedRomDirectory::LoadResult AppLoader_DeconstructedRomDirect
     // Register the RomFS if a ".romfs" file was found
     if (romfs_iter != files.end() && *romfs_iter != nullptr) {
         romfs = *romfs_iter;
-        system.GetFileSystemController().RegisterRomFS(
-            std::make_unique<FileSys::RomFSFactory>(*this));
+        system.GetFileSystemController().RegisterRomFS(std::make_unique<FileSys::RomFSFactory>(
+            *this, system.GetContentProvider(), system.GetFileSystemController()));
     }
 
     is_loaded = true;

src/core/loader/nca.cpp

@@ -58,8 +58,8 @@ AppLoader_NCA::LoadResult AppLoader_NCA::Load(Kernel::Process& process, Core::Sy
     }
 
     if (nca->GetRomFS() != nullptr && nca->GetRomFS()->GetSize() > 0) {
-        system.GetFileSystemController().RegisterRomFS(
-            std::make_unique<FileSys::RomFSFactory>(*this));
+        system.GetFileSystemController().RegisterRomFS(std::make_unique<FileSys::RomFSFactory>(
+            *this, system.GetContentProvider(), system.GetFileSystemController()));
     }
 
     is_loaded = true;

src/core/loader/nro.cpp

@@ -218,8 +218,8 @@ AppLoader_NRO::LoadResult AppLoader_NRO::Load(Kernel::Process& process, Core::Sy
     }
 
     if (romfs != nullptr) {
-        system.GetFileSystemController().RegisterRomFS(
-            std::make_unique<FileSys::RomFSFactory>(*this));
+        system.GetFileSystemController().RegisterRomFS(std::make_unique<FileSys::RomFSFactory>(
+            *this, system.GetContentProvider(), system.GetFileSystemController()));
     }
 
     is_loaded = true;

src/core/loader/nso.cpp

@@ -165,8 +165,7 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::Process& process, Core::S
     return load_base + image_size;
 }
 
-AppLoader_NSO::LoadResult AppLoader_NSO::Load(Kernel::Process& process,
-                                              [[maybe_unused]] Core::System& system) {
+AppLoader_NSO::LoadResult AppLoader_NSO::Load(Kernel::Process& process, Core::System& system) {
     if (is_loaded) {
         return {ResultStatus::ErrorAlreadyLoaded, {}};
     }