OS: add in IStorage::IStorage

Author: N3xoX1

src/nxemu-loader/core/file_sys/vfs/vfs_types.cpp

@@ -61,11 +61,11 @@ uint64_t VirtualFilePtr::GetSize() const
     return 0;
 }
 
-uint64_t VirtualFilePtr::ReadBytes(uint8_t * data, uint64_t datalen)
+uint64_t VirtualFilePtr::ReadBytes(uint8_t * data, uint64_t datalen, uint64_t offset)
 {
     if (m_file)
     {
-        return m_file->Read(data, datalen);
+        return m_file->Read(data, datalen, offset);
     }
     return 0;
 }
@@ -80,6 +80,11 @@ IVirtualDirectory * VirtualFilePtr::ExtractRomFS()
     return std::make_unique<VirtualDirectoryPtr>(dir).release();
 }
 
+IVirtualFile * VirtualFilePtr::Duplicate()
+{
+    return std::make_unique<VirtualFilePtr>(m_file).release();
+}
+
 void VirtualFilePtr::Release()
 {
     delete this;

src/nxemu-loader/core/file_sys/vfs/vfs_types.h

@@ -73,8 +73,9 @@ class VirtualFilePtr :
 
     // IVirtualFile
     uint64_t GetSize() const override;
-    uint64_t ReadBytes(uint8_t* data, uint64_t datalen) override;
+    uint64_t ReadBytes(uint8_t* data, uint64_t datalen, uint64_t offset) override;
     IVirtualDirectory * ExtractRomFS() override;
+    IVirtualFile* Duplicate() override;
     void Release() override;
 
 private:

src/nxemu-loader/system_loader.h

@@ -25,13 +25,13 @@ class Systemloader :
     void RegisterContentProvider(FileSys::ContentProviderUnionSlot slot, FileSys::ContentProvider* provider);
 
     //ISystemloader
-    bool Initialize();
-    bool SelectAndLoad(void * parentWindow);
-    bool LoadRom(const char * romFile);
+    bool Initialize() override;
+    bool SelectAndLoad(void * parentWindow) override;
+    bool LoadRom(const char * romFile) override;
 
-    IFileSystemController & FileSystemController();
-    IVirtualFile * SynthesizeSystemArchive(const uint64_t title_id);
-    uint32_t GetContentProviderEntriesCount(bool useTitleType, LoaderTitleType titleType, bool useContentRecordType, LoaderContentRecordType contentRecordType, bool useTitleId, unsigned long long titleId);
+    IFileSystemController & FileSystemController() override;
+    IVirtualFile * SynthesizeSystemArchive(const uint64_t title_id) override;
+    uint32_t GetContentProviderEntriesCount(bool useTitleType, LoaderTitleType titleType, bool useContentRecordType, LoaderContentRecordType contentRecordType, bool useTitleId, unsigned long long titleId) override;
 
 private:
     Systemloader() = delete;

src/nxemu-module-spec/base.h

@@ -16,7 +16,7 @@
 
 enum
 {
-    MODULE_LOADER_SPECS_VERSION = 0x0103,
+    MODULE_LOADER_SPECS_VERSION = 0x0104,
     MODULE_VIDEO_SPECS_VERSION = 0x0101,
     MODULE_CPU_SPECS_VERSION = 0x0101,
     MODULE_OPERATING_SYSTEM_SPECS_VERSION = 0x0103,

src/nxemu-module-spec/system_loader.h

@@ -106,8 +106,9 @@ __interface IVirtualDirectory
 __interface IVirtualFile
 {
     uint64_t GetSize() const = 0;
-    uint64_t ReadBytes(uint8_t * data, uint64_t datalen) = 0;
+    uint64_t ReadBytes(uint8_t * data, uint64_t datalen, uint64_t offset) = 0;
     IVirtualDirectory * ExtractRomFS() = 0;
+    IVirtualFile * Duplicate() = 0;
     void Release() = 0;
 };
 

src/nxemu-os/core/core.h

@@ -33,9 +33,10 @@ class KProcess;
 class KScheduler;
 } // namespace Kernel
 
+enum class LoaderResultStatus : uint16_t;
+
 namespace Loader {
 class AppLoader;
-enum class ResultStatus : u16;
 } // namespace Loader
 
 namespace Core::Memory {
@@ -311,7 +312,7 @@ class System {
     [[nodiscard]] u64 GetApplicationProcessProgramID() const;
 
     /// Gets the name of the current game
-    [[nodiscard]] Loader::ResultStatus GetGameName(std::string& out) const;
+    [[nodiscard]] LoaderResultStatus GetGameName(std::string& out) const;
 
     void SetStatus(SystemResultStatus new_status, const char* details);
 

src/nxemu-os/core/file_sys/filesystem_interfaces.cpp

@@ -139,7 +139,7 @@ std::vector<uint8_t> IVirtualFilePtr::ReadAllBytes() const
     }
     std::vector<uint8_t> data;
     data.resize(dataSize);
-    dataSize = m_file->ReadBytes(data.data(), data.size());
+    dataSize = m_file->ReadBytes(data.data(), data.size(), 0);
     if (dataSize < data.size())
     {
         data.resize(dataSize);

src/nxemu-os/core/hle/service/filesystem/fsp/fs_i_storage.cpp

@@ -4,7 +4,43 @@
 #include "core/file_sys/errors.h"
 #include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/filesystem/fsp/fs_i_storage.h"
+#include <nxemu-module-spec/system_loader.h>
 
 namespace Service::FileSystem {
 
+IStorage::IStorage(Core::System& system_, IVirtualFilePtr && backend_)
+    : ServiceFramework{system_, "IStorage"}, backend(std::move(backend_)) {
+    static const FunctionInfo functions[] = {
+        {0, D<&IStorage::Read>, "Read"},
+        {1, nullptr, "Write"},
+        {2, nullptr, "Flush"},
+        {3, nullptr, "SetSize"},
+        {4, D<&IStorage::GetSize>, "GetSize"},
+        {5, nullptr, "OperateRange"},
+    };
+    RegisterHandlers(functions);
+}
+
+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);
+
+    R_UNLESS(length >= 0, FileSys::ResultInvalidSize);
+    R_UNLESS(offset >= 0, FileSys::ResultInvalidOffset);
+
+    // Read the data from the Storage backend
+    backend->ReadBytes(out_bytes.data(), length, offset);
+
+    R_SUCCEED();
+}
+
+Result IStorage::GetSize(Out<u64> out_size) {
+    *out_size = backend->GetSize();
+
+    LOG_DEBUG(Service_FS, "called, size={}", *out_size);
+
+    R_SUCCEED();
+}
+
 } // namespace Service::FileSystem

src/nxemu-os/core/hle/service/filesystem/fsp/fs_i_storage.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include "core/file_sys/filesystem_interfaces.h"
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/service.h"
@@ -11,8 +12,15 @@ namespace Service::FileSystem {
 
 class IStorage final : public ServiceFramework<IStorage> {
 public:
+    explicit IStorage(Core::System& system_, IVirtualFilePtr && backend_);
 
 private:
+    IVirtualFilePtr backend;
+
+    Result Read(
+        OutBuffer<BufferAttr_HipcMapAlias | BufferAttr_HipcMapTransferAllowsNonSecure> out_bytes,
+        s64 offset, s64 length);
+    Result GetSize(Out<u64> out_size);
 };
 
 } // namespace Service::FileSystem

src/nxemu-os/core/hle/service/filesystem/fsp/fsp_srv.cpp

@@ -238,11 +238,16 @@ Result FSP_SRV::OpenDataStorageByCurrentProcess(OutInterface<IStorage> out_inter
     LOG_DEBUG(Service_FS, "called");
 
     if (!romfs) {
-        auto current_romfs = romfs_controller->OpenRomFSCurrentProcess();
-        UNIMPLEMENTED();
+        IVirtualFilePtr current_romfs = std::move(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!");
+            R_RETURN(ResultUnknown);
+        }
+
+        romfs = std::move(current_romfs);
     }
-
-    UNIMPLEMENTED();
+    *out_interface = std::make_shared<IStorage>(system, IVirtualFilePtr(romfs->Duplicate()));
     R_SUCCEED();
 }