fusee_cpp: implement emummc/system partition mounting

fusee_cpp/program/source/fs/fusee_fs_api.cpp

@@ -24,8 +24,10 @@ namespace ams::fs {
         constexpr size_t MaxFiles = 8;
 
         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] = {};
         constinit bool g_files_opened[MaxFiles] = {};
@@ -104,16 +106,40 @@ namespace ams::fs {
 
     bool MountSdCard() {
         AMS_ASSERT(!g_is_sd_mounted);
-        g_is_sd_mounted = f_mount(std::addressof(g_sd_fs), "sdmc", 1) == FR_OK;
+        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("");
+        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;

fusee_cpp/program/source/fs/fusee_fs_api.hpp

@@ -69,13 +69,27 @@ namespace ams::fs {
 
     static_assert(util::is_pod<WriteOption>::value && sizeof(WriteOption) == sizeof(u32));
 
+    enum DirectoryEntryType {
+        DirectoryEntryType_Directory = 0,
+        DirectoryEntryType_File      = 1,
+    };
+
     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);

fusee_cpp/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_cpp/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;
+    };
+
+}