fusee_cpp: rename source dir to fusee

fusee/program/source/fs/fusee_fs_api.cpp

@@ -0,0 +1,341 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <exosphere.hpp>
+#include "../fatfs/ff.h"
+#include "fusee_fs_api.hpp"
+
+namespace ams::fs {
+
+    static_assert(sizeof(DirectoryEntry) == sizeof(FILINFO));
+
+    namespace {
+
+        constexpr size_t MaxFiles = 8 + 64;
+        constexpr size_t MaxDirectories = 2;
+
+        constinit bool g_is_sd_mounted = false;
+        constinit bool g_is_sys_mounted = false;
+
+        alignas(0x10) constinit FATFS g_sd_fs = {};
+        alignas(0x10) constinit FATFS g_sys_fs = {};
+
+        alignas(0x10) constinit FIL g_files[MaxFiles] = {};
+        alignas(0x10) constinit DIR g_dirs[MaxDirectories] = {};
+        constinit bool g_files_opened[MaxFiles] = {};
+        constinit bool g_dirs_opened[MaxFiles] = {};
+        constinit int g_open_modes[MaxFiles] = {};
+
+        Result TranslateFatFsError(FRESULT res) {
+            switch (res) {
+                case FR_OK:
+                    return ResultSuccess();
+                case FR_DISK_ERR:
+                    return fs::ResultMmcAccessFailed();
+                case FR_INT_ERR:
+                    return fs::ResultPreconditionViolation();
+                case FR_NOT_READY:
+                    return fs::ResultMmcAccessFailed();
+                case FR_NO_FILE:
+                    return fs::ResultPathNotFound();
+                case FR_NO_PATH:
+                    return fs::ResultPathNotFound();
+                case FR_INVALID_NAME:
+                    return fs::ResultInvalidPath();
+                case FR_DENIED:
+                    return fs::ResultPermissionDenied();
+                case FR_EXIST:
+                    return fs::ResultPathAlreadyExists();
+                case FR_INVALID_OBJECT:
+                    return fs::ResultInvalidArgument();
+                case FR_WRITE_PROTECTED:
+                    return fs::ResultWriteNotPermitted();
+                case FR_INVALID_DRIVE:
+                    return fs::ResultInvalidMountName();
+                case FR_NOT_ENABLED:
+                    return fs::ResultInvalidMountName(); /* BAD/TODO */
+                case FR_NO_FILESYSTEM:
+                    return fs::ResultInvalidMountName(); /* BAD/TODO */
+                case FR_TIMEOUT:
+                    return fs::ResultTargetLocked(); /* BAD/TODO */
+                case FR_LOCKED:
+                    return fs::ResultTargetLocked();
+                case FR_NOT_ENOUGH_CORE:
+                    return fs::ResultPreconditionViolation(); /* BAD/TODO */
+                case FR_TOO_MANY_OPEN_FILES:
+                    return fs::ResultPreconditionViolation(); /* BAD/TODO */
+                case FR_INVALID_PARAMETER:
+                    return fs::ResultInvalidArgument();
+                default:
+                    return fs::ResultInternal();
+            }
+        }
+
+        int TranslateToFatFsMode(int mode) {
+            int fmode = FA_OPEN_EXISTING;
+            if ((mode & OpenMode_Read) != 0) {
+                fmode |= FA_READ;
+            }
+            if ((mode & OpenMode_Write) != 0) {
+                fmode |= FA_WRITE;
+            }
+            if ((mode & OpenMode_AllowAppend) != 0) {
+                fmode |= FA_OPEN_APPEND;
+            }
+            return fmode;
+        }
+
+        FIL *GetInternalFile(FileHandle handle) {
+            return static_cast<FIL *>(handle._handle);
+        }
+
+        DIR *GetInternalDirectory(DirectoryHandle handle) {
+            return static_cast<DIR *>(handle._handle);
+        }
+
+        ALWAYS_INLINE size_t GetFileIndex(FIL *fp) {
+            const size_t file_index = (fp - g_files);
+            AMS_ASSERT(file_index < MaxFiles);
+            return file_index;
+        }
+
+        ALWAYS_INLINE size_t GetDirectoryIndex(DIR *dp) {
+            const size_t dir_index = (dp - g_dirs);
+            AMS_ASSERT(dir_index < MaxDirectories);
+            return dir_index;
+        }
+
+    }
+
+    bool MountSdCard() {
+        AMS_ASSERT(!g_is_sd_mounted);
+        g_is_sd_mounted = f_mount(std::addressof(g_sd_fs), "sdmc:", 1) == FR_OK;
+        return g_is_sd_mounted;
+    }
+
+    void UnmountSdCard() {
+        AMS_ASSERT(g_is_sd_mounted);
+        f_unmount("sdmc:");
+        g_is_sd_mounted = false;
+    }
+
+    bool MountSystem() {
+        AMS_ASSERT(!g_is_sys_mounted);
+        g_is_sys_mounted = f_mount(std::addressof(g_sys_fs), "sys:", 1) == FR_OK;
+        return g_is_sys_mounted;
+    }
+
+    void UnmountSystem() {
+        AMS_ASSERT(g_is_sys_mounted);
+        f_unmount("sys:");
+        g_is_sys_mounted = false;
+    }
+
+    Result GetEntryType(DirectoryEntryType *out_entry_type, bool *out_archive, const char *path) {
+        /* Get the file info. */
+        FILINFO info;
+        R_TRY(TranslateFatFsError(f_stat(path, std::addressof(info))));
+
+        /* Handle the file. */
+        *out_entry_type = (info.fattrib & AM_DIR) ? DirectoryEntryType_Directory : DirectoryEntryType_File;
+        *out_archive    = (info.fattrib & AM_ARC);
+
+        return ResultSuccess();
+    }
+
+    Result CreateFile(const char *path, s64 size) {
+        /* Create the file. */
+        FIL fp;
+        R_TRY(TranslateFatFsError(f_open(std::addressof(fp), path, FA_CREATE_NEW | FA_READ | FA_WRITE)));
+
+        /* Ensure that we close the file when we're done with it. */
+        ON_SCOPE_EXIT { f_close(std::addressof(fp)); };
+
+        /* Expand the file. */
+        R_TRY(TranslateFatFsError(f_expand(std::addressof(fp), size, 1)));
+
+        return ResultSuccess();
+    }
+
+    Result CreateDirectory(const char *path) {
+        return TranslateFatFsError(f_mkdir(path));
+    }
+
+    Result OpenFile(FileHandle *out_file, const char *path, int mode) {
+        /* Find a free file. */
+        for (size_t i = 0; i < MaxFiles; ++i) {
+            if (!g_files_opened[i]) {
+                /* Open the file. */
+                FIL *fp = std::addressof(g_files[i]);
+                R_TRY(TranslateFatFsError(f_open(fp, path, TranslateToFatFsMode(mode))));
+
+                /* Set the output. */
+                out_file->_handle = fp;
+                g_files_opened[i] = true;
+                g_open_modes[i] = mode;
+                return ResultSuccess();
+            }
+        }
+        return fs::ResultOpenCountLimit();
+    }
+
+    Result OpenDirectory(DirectoryHandle *out_dir, const char *path) {
+        /* Find a free directory. */
+        for (size_t i = 0; i < MaxDirectories; ++i) {
+            if (!g_dirs_opened[i]) {
+                /* Open the file. */
+                DIR *dp = std::addressof(g_dirs[i]);
+                R_TRY(TranslateFatFsError(f_opendir(dp, path)));
+
+                /* Set the output. */
+                out_dir->_handle = dp;
+                g_dirs_opened[i] = true;
+                return ResultSuccess();
+            }
+        }
+        return fs::ResultOpenCountLimit();
+    }
+
+    Result ReadDirectory(s64 *out_count, DirectoryEntry *out_entries, DirectoryHandle handle, s64 max_entries) {
+        DIR * const dp = GetInternalDirectory(handle);
+
+        s64 count = 0;
+        while (count < max_entries) {
+            R_TRY(TranslateFatFsError(f_readdir(dp, reinterpret_cast<FILINFO *>(out_entries + count))));
+
+            if (out_entries[count].file_name[0] == '\x00') {
+                break;
+            }
+
+            ++count;
+        }
+
+        *out_count = count;
+        return ResultSuccess();
+    }
+
+    void CloseDirectory(DirectoryHandle handle) {
+        const size_t index = GetDirectoryIndex(GetInternalDirectory(handle));
+        f_closedir(std::addressof(g_dirs[index]));
+        g_dirs_opened[index] = false;
+    }
+
+    Result ReadFile(FileHandle handle, s64 offset, void *buffer, size_t size, const fs::ReadOption &option) {
+        /* Option is unused. */
+        AMS_UNUSED(option);
+
+        /* Seek to the offset we're reading at. */
+        R_TRY(TranslateFatFsError(f_lseek(GetInternalFile(handle), offset)));
+
+        /* Read the data. */
+        UINT br;
+        R_TRY(TranslateFatFsError(f_read(GetInternalFile(handle), buffer, size, std::addressof(br))));
+
+        /* Check that we read the correct amount. */
+        R_UNLESS(br == size, fs::ResultOutOfRange());
+
+        return ResultSuccess();
+    }
+
+    Result ReadFile(FileHandle handle, s64 offset, void *buffer, size_t size) {
+        return ReadFile(handle, offset, buffer, size, fs::ReadOption::None);
+    }
+
+    Result ReadFile(size_t *out, FileHandle handle, s64 offset, void *buffer, size_t size, const fs::ReadOption &option) {
+        /* Option is unused. */
+        AMS_UNUSED(option);
+
+        /* Seek to the offset we're reading at. */
+        R_TRY(TranslateFatFsError(f_lseek(GetInternalFile(handle), offset)));
+
+        /* Read the data. */
+        UINT br;
+        R_TRY(TranslateFatFsError(f_read(GetInternalFile(handle), buffer, size, std::addressof(br))));
+
+        /* Set the output size. */
+        *out = br;
+
+        return ResultSuccess();
+    }
+
+    Result ReadFile(size_t *out, FileHandle handle, s64 offset, void *buffer, size_t size) {
+        return ReadFile(out, handle, offset, buffer, size, fs::ReadOption::None);
+    }
+
+    Result GetFileSize(s64 *out, FileHandle handle) {
+        FIL *fp = GetInternalFile(handle);
+        *out = f_size(fp);
+        return ResultSuccess();
+    }
+
+    Result FlushFile(FileHandle handle) {
+        return TranslateFatFsError(f_sync(GetInternalFile(handle)));
+    }
+
+    Result WriteFile(FileHandle handle, s64 offset, const void *buffer, size_t size, const fs::WriteOption &option) {
+        /* Seek to the offset we're writing at. */
+        R_TRY(TranslateFatFsError(f_lseek(GetInternalFile(handle), offset)));
+
+        /* Write the data. */
+        UINT bw;
+        R_TRY(TranslateFatFsError(f_write(GetInternalFile(handle), buffer, size, std::addressof(bw))));
+
+        /* Check that we wrote the correct amount. */
+        R_UNLESS(bw == size, fs::ResultOutOfRange());
+
+        /* If we should, flush the file. */
+        if (option.HasFlushFlag()) {
+            R_TRY(FlushFile(handle));
+        }
+
+        return ResultSuccess();
+    }
+
+    Result SetFileSize(FileHandle handle, s64 size) {
+        FIL *fp = GetInternalFile(handle);
+
+        /* Check if we have nothing to do. */
+        const size_t fsize = f_size(fp);
+        R_SUCCEED_IF(static_cast<FSIZE_t>(size) == fsize);
+
+        /* NOTE/TODO: This may not preserve file data. Do this in a way that does? */
+
+        /* Truncate the file. */
+        R_TRY(TranslateFatFsError(f_truncate(fp)));
+
+        /* Expand the file. */
+        R_TRY(TranslateFatFsError(f_expand(fp, size, 1)));
+
+        /* Ensure the file is synchronized. */
+        R_TRY(FlushFile(handle));
+
+        /* Check that our expansion succeeded. */
+        AMS_ASSERT(f_size(fp) == static_cast<FSIZE_t>(size));
+
+        return ResultSuccess();
+    }
+
+    int GetFileOpenMode(FileHandle handle) {
+        return g_open_modes[GetFileIndex(GetInternalFile(handle))];
+    }
+
+    void CloseFile(FileHandle handle) {
+        const size_t index = GetFileIndex(GetInternalFile(handle));
+        f_close(std::addressof(g_files[index]));
+        g_open_modes[index] = 0;
+        g_files_opened[index] = false;
+    }
+
+}

fusee/program/source/fs/fusee_fs_api.hpp

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <exosphere.hpp>
+
+namespace ams::fs {
+
+    enum OpenMode {
+        OpenMode_Read   = (1 << 0),
+        OpenMode_Write  = (1 << 1),
+        OpenMode_AllowAppend = (1 << 2),
+
+        OpenMode_ReadWrite = (OpenMode_Read | OpenMode_Write),
+        OpenMode_All       = (OpenMode_ReadWrite | OpenMode_AllowAppend),
+    };
+
+    struct ReadOption {
+        u32 value;
+
+        static const ReadOption None;
+    };
+
+    inline constexpr const ReadOption ReadOption::None = {0};
+
+    inline constexpr bool operator==(const ReadOption &lhs, const ReadOption &rhs) {
+        return lhs.value == rhs.value;
+    }
+
+    inline constexpr bool operator!=(const ReadOption &lhs, const ReadOption &rhs) {
+        return !(lhs == rhs);
+    }
+
+    static_assert(util::is_pod<ReadOption>::value && sizeof(ReadOption) == sizeof(u32));
+
+    struct WriteOption {
+        u32 value;
+
+        constexpr inline bool HasFlushFlag() const {
+            return this->value & 1;
+        }
+
+        static const WriteOption None;
+        static const WriteOption Flush;
+    };
+
+    inline constexpr const WriteOption WriteOption::None = {0};
+    inline constexpr const WriteOption WriteOption::Flush = {1};
+
+    inline constexpr bool operator==(const WriteOption &lhs, const WriteOption &rhs) {
+        return lhs.value == rhs.value;
+    }
+
+    inline constexpr bool operator!=(const WriteOption &lhs, const WriteOption &rhs) {
+        return !(lhs == rhs);
+    }
+
+    static_assert(util::is_pod<WriteOption>::value && sizeof(WriteOption) == sizeof(u32));
+
+    enum DirectoryEntryType {
+        DirectoryEntryType_Directory = 0,
+        DirectoryEntryType_File      = 1,
+    };
+
+    struct DirectoryEntry {
+        u64 file_size;
+        u16 file_date;
+        u16 file_time;
+        u8 file_attr;
+        char altname[13];
+        char file_name[0x100];
+    };
+
+    constexpr ALWAYS_INLINE DirectoryEntryType GetEntryType(const DirectoryEntry &entry) {
+        return (entry.file_attr & 0x10) ? DirectoryEntryType_Directory : DirectoryEntryType_File;
+    }
+
+    struct FileHandle {
+        void *_handle;
+    };
+
+    struct DirectoryHandle {
+        void *_handle;
+    };
+
+    bool MountSdCard();
+    void UnmountSdCard();
+
+    bool MountSystem();
+    void UnmountSystem();
+
+    Result GetEntryType(DirectoryEntryType *out_entry_type, bool *out_archive, const char *path);
+
+    Result CreateFile(const char *path, s64 size);
+    Result CreateDirectory(const char *path);
+    Result OpenFile(FileHandle *out_file, const char *path, int mode);
+
+    Result OpenDirectory(DirectoryHandle *out_dir, const char *path);
+
+    Result ReadDirectory(s64 *out_count, DirectoryEntry *out_entries, DirectoryHandle handle, s64 max_entries);
+    void CloseDirectory(DirectoryHandle handle);
+
+    Result ReadFile(FileHandle handle, s64 offset, void *buffer, size_t size, const fs::ReadOption &option);
+    Result ReadFile(FileHandle handle, s64 offset, void *buffer, size_t size);
+    Result ReadFile(size_t *out, FileHandle handle, s64 offset, void *buffer, size_t size, const fs::ReadOption &option);
+    Result ReadFile(size_t *out, FileHandle handle, s64 offset, void *buffer, size_t size);
+    Result GetFileSize(s64 *out, FileHandle handle);
+    Result FlushFile(FileHandle handle);
+    Result WriteFile(FileHandle handle, s64 offset, const void *buffer, size_t size, const fs::WriteOption &option);
+    Result SetFileSize(FileHandle handle, s64 size);
+    int GetFileOpenMode(FileHandle handle);
+    void CloseFile(FileHandle handle);
+
+}

fusee/program/source/fs/fusee_fs_file_storage.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <exosphere.hpp>
+#include "fusee_fs_storage.hpp"
+
+namespace ams::fs {
+
+    Result FileHandleStorage::UpdateSize() {
+        R_SUCCEED_IF(m_size != InvalidSize);
+        return GetFileSize(std::addressof(m_size), m_handle);
+    }
+
+    Result FileHandleStorage::Read(s64 offset, void *buffer, size_t size) {
+        /* Immediately succeed if there's nothing to read. */
+        R_SUCCEED_IF(size == 0);
+
+        /* Validate buffer. */
+        R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument());
+
+        /* Ensure our size is valid. */
+        R_TRY(this->UpdateSize());
+
+        /* Ensure our access is valid. */
+        R_UNLESS(IStorage::CheckAccessRange(offset, size, m_size), fs::ResultOutOfRange());
+
+        return ReadFile(m_handle, offset, buffer, size, fs::ReadOption());
+    }
+
+    Result FileHandleStorage::Write(s64 offset, const void *buffer, size_t size) {
+        /* Immediately succeed if there's nothing to write. */
+        R_SUCCEED_IF(size == 0);
+
+        /* Validate buffer. */
+        R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument());
+
+        /* Ensure our size is valid. */
+        R_TRY(this->UpdateSize());
+
+        /* Ensure our access is valid. */
+        R_UNLESS(IStorage::CheckAccessRange(offset, size, m_size), fs::ResultOutOfRange());
+
+        return WriteFile(m_handle, offset, buffer, size, fs::WriteOption());
+    }
+
+    Result FileHandleStorage::Flush() {
+        return FlushFile(m_handle);
+    }
+
+    Result FileHandleStorage::GetSize(s64 *out_size) {
+        R_TRY(this->UpdateSize());
+        *out_size = m_size;
+        return ResultSuccess();
+    }
+
+    Result FileHandleStorage::SetSize(s64 size) {
+        m_size = InvalidSize;
+        return SetFileSize(m_handle, size);
+    }
+
+}

fusee/program/source/fs/fusee_fs_storage.hpp

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <exosphere.hpp>
+#include "fusee_fs_api.hpp"
+
+namespace ams::fs {
+
+    class IStorage {
+        public:
+            virtual Result Read(s64 offset, void *buffer, size_t size) = 0;
+
+            virtual Result Write(s64 offset, const void *buffer, size_t size) = 0;
+
+            virtual Result Flush() = 0;
+
+            virtual Result SetSize(s64 size) = 0;
+
+            virtual Result GetSize(s64 *out) = 0;
+        public:
+            static inline bool CheckAccessRange(s64 offset, s64 size, s64 total_size) {
+                return offset >= 0 &&
+                       size >= 0 &&
+                       size <= total_size &&
+                       offset <= (total_size - size);
+            }
+
+            static inline bool CheckAccessRange(s64 offset, size_t size, s64 total_size) {
+                return CheckAccessRange(offset, static_cast<s64>(size), total_size);
+            }
+
+            static inline bool CheckOffsetAndSize(s64 offset, s64 size) {
+                return offset >= 0 &&
+                       size >= 0 &&
+                       offset <= (offset + size);
+            }
+
+            static inline bool CheckOffsetAndSize(s64 offset, size_t size) {
+                return CheckOffsetAndSize(offset, static_cast<s64>(size));
+            }
+    };
+
+    class ReadOnlyStorageAdapter : public IStorage {
+        private:
+            IStorage &m_storage;
+        public:
+            ReadOnlyStorageAdapter(IStorage &s) : m_storage(s) { /* ... */ }
+
+            virtual Result Read(s64 offset, void *buffer, size_t size) override {
+                return m_storage.Read(offset, buffer, size);
+            }
+
+            virtual Result Flush() override {
+                return m_storage.Flush();
+            }
+
+            virtual Result GetSize(s64 *out) override {
+                return m_storage.GetSize(out);
+            }
+
+            virtual Result Write(s64 offset, const void *buffer, size_t size) override {
+                return fs::ResultUnsupportedOperation();
+            }
+
+            virtual Result SetSize(s64 size) override {
+                return fs::ResultUnsupportedOperation();
+            }
+    };
+
+    class SubStorage : public IStorage {
+        private:
+            IStorage &m_storage;
+            s64 m_offset;
+            s64 m_size;
+        public:
+            SubStorage(IStorage &s, s64 o, s64 sz) : m_storage(s), m_offset(o), m_size(sz) { /* ... */ }
+
+            virtual Result Read(s64 offset, void *buffer, size_t size) override {
+                /* Succeed immediately on zero-sized operation. */
+                R_SUCCEED_IF(size == 0);
+
+                /* Validate arguments and read. */
+                R_UNLESS(buffer != nullptr,                                fs::ResultNullptrArgument());
+                R_UNLESS(IStorage::CheckAccessRange(offset, size, m_size), fs::ResultOutOfRange());
+                return m_storage.Read(m_offset + offset, buffer, size);
+            }
+
+            virtual Result Write(s64 offset, const void *buffer, size_t size) override{
+                /* Succeed immediately on zero-sized operation. */
+                R_SUCCEED_IF(size == 0);
+
+                /* Validate arguments and write. */
+                R_UNLESS(buffer != nullptr,                                fs::ResultNullptrArgument());
+                R_UNLESS(IStorage::CheckAccessRange(offset, size, m_size), fs::ResultOutOfRange());
+                return m_storage.Write(m_offset + offset, buffer, size);
+            }
+
+            virtual Result Flush() override {
+                return m_storage.Flush();
+            }
+
+            virtual Result GetSize(s64 *out) override {
+                *out = m_size;
+                return ResultSuccess();
+            }
+
+            virtual Result SetSize(s64 size) override {
+                return fs::ResultUnsupportedOperationInSubStorageA();
+            }
+    };
+
+    class FileHandleStorage : public IStorage {
+        private:
+            static constexpr s64 InvalidSize = -1;
+        private:
+            FileHandle m_handle;
+            s64 m_size;
+        public:
+            constexpr explicit FileHandleStorage(FileHandle handle) : m_handle(handle), m_size(InvalidSize) { /* ... */ }
+
+            ~FileHandleStorage() { fs::CloseFile(m_handle); }
+        protected:
+            Result UpdateSize();
+        public:
+            virtual Result Read(s64 offset, void *buffer, size_t size) override;
+            virtual Result Write(s64 offset, const void *buffer, size_t size) override;
+            virtual Result Flush() override;
+            virtual Result GetSize(s64 *out_size) override;
+            virtual Result SetSize(s64 size) override;
+    };
+
+}