Implement the NCM sysmodule (closes #91)

* Implement NCM * Modernize ncm_main * Remove unnecessary smExit * Give access to svcCallSecureMonitor * Stack size bump * Fix incorrect setup for NandUser's content storage entry * Fix a potential data abort when flushing the placeholder accessor cache * Fix HasFile and HasDirectory * Use r+b, not w+b * Misc fixes * errno begone * Fixed more stdio error handling * More main fixes * Various command improvements * Make dispatch tables great again * Fix logic inversion * Fixed content path generation * Bump heap size, fix CleanupAllPlaceHolder * Various fixes. Note: This contains debug stuff which will be removed later. I was getting tired of having to cherrypick tiny changes * Fixed placeholder/content deletion * Fixed incorrect content manager destruction * Prevent automatic placeholder creation on open * Fixed List implementation. Also lots of debug logging. * Removed debug code * Added a scope guard for WritePlaceHolder * Manually prevent placeholder/content appending * Revert "Removed debug code" This reverts commit d6ff261fcc. * Always cache placeholder file. Switch to ftell for preventing appending * Universally use EnsureEnabled * Abstract away file writing logic * Misc cleanup * Refactor placeholder cacheing * Remove debug code (again) * Revert "Remove debug code (again)" This reverts commit 168447d80e. * Misc changes * Fixed file modes * Fixed ContentId/PlaceHolderId alignment * Improved type safety * Fixed reinitialization * Fixed doubleup on path creation * Remove debug code * Fixed 1.0.0 booting * Correct amount of add on content * Correct main thread stack size * lr: Introducing registered data * Reorder stratosphere Makefile * Move results to libstrat * lr: Cleanup lr_redirection * lr: lr_manager tweaks * lr: Imrpoved path handling and adjust ResolveAddOnContentPath order * lr: Organise types * Add eof newlines * lr: Eliminate unnecessary vars * lr: Unnecessary vars 2 electric boogaloo * lr: Various helpers * lr: RegisteredLocationResolver helpers * ncm: Move ncm_types to libstrat * ncm: Misc cleanup * Implement NCM * Modernize ncm_main * Remove unnecessary smExit * Give access to svcCallSecureMonitor * Stack size bump * Fix incorrect setup for NandUser's content storage entry * Fix a potential data abort when flushing the placeholder accessor cache * Fix HasFile and HasDirectory * Use r+b, not w+b * Misc fixes * errno begone * Fixed more stdio error handling * More main fixes * Various command improvements * Make dispatch tables great again * Fix logic inversion * Fixed content path generation * Bump heap size, fix CleanupAllPlaceHolder * Various fixes. Note: This contains debug stuff which will be removed later. I was getting tired of having to cherrypick tiny changes * Fixed placeholder/content deletion * Fixed incorrect content manager destruction * Prevent automatic placeholder creation on open * Fixed List implementation. Also lots of debug logging. * Removed debug code * Added a scope guard for WritePlaceHolder * Manually prevent placeholder/content appending * Revert "Removed debug code" This reverts commit d6ff261fcc. * Always cache placeholder file. Switch to ftell for preventing appending * Universally use EnsureEnabled * Abstract away file writing logic * Misc cleanup * Refactor placeholder cacheing * Remove debug code (again) * Revert "Remove debug code (again)" This reverts commit 168447d80e. * Misc changes * Fixed file modes * Fixed ContentId/PlaceHolderId alignment * Improved type safety * Fixed reinitialization * Fixed doubleup on path creation * Remove debug code * Fixed 1.0.0 booting * Correct amount of add on content * Correct main thread stack size * lr: Introducing registered data * Reorder stratosphere Makefile * Move results to libstrat * lr: Cleanup lr_redirection * lr: lr_manager tweaks * lr: Imrpoved path handling and adjust ResolveAddOnContentPath order * lr: Organise types * Add eof newlines * lr: Eliminate unnecessary vars * lr: Unnecessary vars 2 electric boogaloo * lr: Various helpers * lr: RegisteredLocationResolver helpers * ncm: Move ncm_types to libstrat * ncm: Misc cleanup * Updated AddOnContentLocationResolver and RegisteredLocationResolver to 9.0.0 * Finished updating lr to 9.0.0 * Updated NCM to 9.0.0 * Fix libstrat includes * Fixed application launching * title_id_2 -> owner_tid * Updated to new-ipc * Change to using pure virtuals * Title Id -> Program Id * Fixed compilation against master * std::scoped_lock<> -> std::scoped_lock * Adopted R_UNLESS and R_CONVERT * Prefix namespace to Results * Adopt std::numeric_limits * Fixed incorrect error handling in ReadFile * Adopted AMS_ABORT_UNLESS * Adopt util::GenerateUuid() * Syntax improvements * ncm_types: Address review * Address more review comments * Updated copyrights * Address more feedback * More feedback addressed * More changes * Move dispatch tables out of interface files * Addressed remaining comments * lr: move into libstratosphere * ncm: Fix logic inversion * lr: Add comments * lr: Remove whitespace * ncm: Start addressing feedback * ncm: Cleanup InitializeContentManager * lr: support client-side usage * lr_service -> lr_api * ncm: Begin refactoring content manager * ncm: More content manager improvements * ncm: Content manager mount improvements * ldr: use lr bindings * lr bindings usage: minor fixes * ncm/lr: Pointer placement * ncm: placeholder accessor cleanup * ncm: minor fixes * ncm: refactor rights cache * ncm: content meta database cleanup * ncm: move content meta database impl out of interface file * ncm: Use const ContentMetaKey & * ncm: fix other non-const ContentMetaKey references * ncm: content meta database cleanup * ncm: content storage fixes for 2.0.0 * ncm: add missing end of file newlines * ncm: implement ContentMetaReader * ncm: client-side api * ncm: trim trailing spaces * ncm: FS_MAX_PATH-1 -> fs::EntryNameLengthMax * ncm: Use PathString and Path * fs: implement accessor wrappers for ncm * fs: implement user fs wrappers * fs: add MountSdCard * ncm: move to content manager impl * ncm: fix up main * kvdb: use fs:: * fs: Add wrappers needed for ncm * ncm: use fs bindings, other refactoring * ncm: minor fixes * fsa: fix ReadFile without size output * fs: add substorage, rom path tool * ncm: fix dangling fsdev usage * fs: fix bug in Commit * fs: fixed incorrect mode check * fs: implement Mount(System)Data * ncm: don't delete hos * results: add R_SUCCEED_IF * ams-except-ncm: use R_SUCCEED_IF * ncm: added comments * ncm: fix api definitions * ncm: use R_SUCCEED_IF * pm: think of the savings * ncm: employ kernel strats * ncm: Nintendo has 5 MiB of heap. Give ourselves 4 to be safe, pending analysis * ncm: refactor IDs, split types header into many headers * ams.mitm: use fs bindings instead of stdio * fs: SystemData uses SystemDataId * ncm: improve meta-db accuracy * ncm: inline getlatestkey * fs: improve UnsupportedOperation results * fs: modernize mount utils * ams: misc fixes for merge-errors * fs: improve unsupportedoperation results * git subrepo pull emummc subrepo: subdir: "emummc" merged: "d12dd546" upstream: origin: "https://github.com/m4xw/emuMMC" branch: "develop" commit: "d12dd546" git-subrepo: version: "0.4.1" origin: "???" commit: "???" * util: add boundedmap * ncm: minor style fixes * ncm: don't unmount if mounting fails * lr: bug fixes * ncm: implement ncm.for-initialize + ncm.for-safemode * lr: ncm::ProgramId::Invalid -> ncm::InvalidProgramId * ncm: fix open directory mode on 1.0.0 * ncm: fix fs use, implement more of < 4.0.0 for-initialize/safemode * ncm: implement packagedcontent -> content for building metadb * ncm: fix save data flag management * ncm: address some review suggestions (thanks @leoetlino!) * updater: use fs bindings * fs: implement MountCode * fs: prefer make_unique to operator new * ncm: implement remaining ContentMetaDatabaseBuilder functionality Co-authored-by: Michael Scire <SciresM@gmail.com>
2025-06-04 08:29:44 -04:00 · 2020-03-08 19:06:23 +11:00 · 2020-03-08 19:06:23 +11:00 · c7026b9094
commit c7026b9094
parent f9403201f0
254 changed files with 16876 additions and 1274 deletions
--- a/libraries/libstratosphere/source/fs/fsa/fs_directory_accessor.cpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_directory_accessor.cpp
@ -0,0 +1,39 @@
+/*
+ * 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 <stratosphere.hpp>
+#include "fs_directory_accessor.hpp"
+#include "fs_filesystem_accessor.hpp"
+
+namespace ams::fs::impl {
+
+    DirectoryAccessor::DirectoryAccessor(std::unique_ptr<fsa::IDirectory>&& d, FileSystemAccessor &p) : impl(std::move(d)), parent(p) {
+        /* ... */
+    }
+
+    DirectoryAccessor::~DirectoryAccessor() {
+        this->impl.reset();
+        this->parent.NotifyCloseDirectory(this);
+    }
+
+    Result DirectoryAccessor::Read(s64 *out_count, DirectoryEntry *out_entries, s64 max_entries) {
+        return this->impl->Read(out_count, out_entries, max_entries);
+    }
+
+    Result DirectoryAccessor::GetEntryCount(s64 *out) {
+        return this->impl->GetEntryCount(out);
+    }
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_directory_accessor.hpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_directory_accessor.hpp
@ -0,0 +1,38 @@
+/*
+ * 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 <stratosphere.hpp>
+
+namespace ams::fs::impl {
+
+    class FileSystemAccessor;
+
+    class DirectoryAccessor : public util::IntrusiveListBaseNode<DirectoryAccessor>, public Newable {
+        NON_COPYABLE(DirectoryAccessor);
+        private:
+            std::unique_ptr<fsa::IDirectory> impl;
+            FileSystemAccessor &parent;
+        public:
+            DirectoryAccessor(std::unique_ptr<fsa::IDirectory>&& d, FileSystemAccessor &p);
+            ~DirectoryAccessor();
+
+            Result Read(s64 *out_count, DirectoryEntry *out_entries, s64 max_entries);
+            Result GetEntryCount(s64 *out);
+
+            FileSystemAccessor &GetParent() const { return this->parent; }
+    };
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_file_accessor.cpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_file_accessor.cpp
@ -0,0 +1,123 @@
+/*
+ * 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 <stratosphere.hpp>
+#include "../fs_scoped_setter.hpp"
+#include "../fs_file_path_hash.hpp"
+#include "fs_file_accessor.hpp"
+#include "fs_filesystem_accessor.hpp"
+
+namespace ams::fs::impl {
+
+    FileAccessor::FileAccessor(std::unique_ptr<fsa::IFile>&& f, FileSystemAccessor *p, OpenMode mode)
+        : impl(std::move(f)), parent(p), write_state(WriteState::None), write_result(ResultSuccess()), open_mode(mode)
+    {
+        /* ... */
+    }
+
+    FileAccessor::~FileAccessor() {
+        /* Ensure that all files are flushed. */
+        if (R_FAILED(this->write_result)) {
+            AMS_ABORT_UNLESS(this->write_state != WriteState::NeedsFlush);
+        }
+        this->impl.reset();
+
+        if (this->parent != nullptr) {
+            this->parent->NotifyCloseFile(this);
+        }
+    }
+
+    Result FileAccessor::ReadWithCacheAccessLog(size_t *out, s64 offset, void *buf, size_t size, const ReadOption &option, bool use_path_cache, bool use_data_cache) {
+        AMS_ABORT();
+    }
+
+    Result FileAccessor::ReadWithoutCacheAccessLog(size_t *out, s64 offset, void *buf, size_t size, const ReadOption &option) {
+        return this->impl->Read(out, offset, buf, size, option);
+    }
+
+    Result FileAccessor::Read(size_t *out, s64 offset, void *buf, size_t size, const ReadOption &option) {
+        /* Fail after a write fails. */
+        R_TRY(this->write_result);
+
+        /* TODO: Logging. */
+        /* TODO: Support cache. */
+        const bool use_path_cache = this->parent != nullptr && this->file_path_hash != nullptr;
+        const bool use_data_cache = /* TODO */false && this->parent != nullptr && this->parent->IsFileDataCacheAttachable();
+
+        if (use_path_cache && use_data_cache && false) {
+            /* TODO */
+            return this->ReadWithCacheAccessLog(out, offset, buf, size, option, use_path_cache, use_data_cache);
+        } else {
+            return this->ReadWithoutCacheAccessLog(out, offset, buf, size, option);
+        }
+    }
+
+    Result FileAccessor::Write(s64 offset, const void *buf, size_t size, const WriteOption &option) {
+        /* Fail after a write fails. */
+        R_TRY(this->write_result);
+
+        auto setter = MakeScopedSetter(this->write_state, WriteState::Failed);
+        if (this->file_path_hash != nullptr && /* TODO */ false) {
+            /* TODO */
+            AMS_ABORT();
+        } else {
+            R_TRY(this->UpdateLastResult(this->impl->Write(offset, buf, size, option)));
+        }
+
+        setter.Set(option.HasFlushFlag() ? WriteState::None : WriteState::NeedsFlush);
+
+        return ResultSuccess();
+    }
+
+    Result FileAccessor::Flush() {
+        /* Fail after a write fails. */
+        R_TRY(this->write_result);
+
+        auto setter = MakeScopedSetter(this->write_state, WriteState::Failed);
+        R_TRY(this->UpdateLastResult(this->impl->Flush()));
+        setter.Set(WriteState::None);
+
+        return ResultSuccess();
+    }
+
+    Result FileAccessor::SetSize(s64 size) {
+        /* Fail after a write fails. */
+        R_TRY(this->write_result);
+
+        const WriteState old_write_state = this->write_state;
+        auto setter = MakeScopedSetter(this->write_state, WriteState::Failed);
+
+        R_TRY(this->UpdateLastResult(this->impl->SetSize(size)));
+
+        if (this->file_path_hash != nullptr) {
+            /* TODO: invalidate path cache */
+        }
+
+        setter.Set(old_write_state);
+        return ResultSuccess();
+    }
+
+    Result FileAccessor::GetSize(s64 *out) {
+        /* Fail after a write fails. */
+        R_TRY(this->write_result);
+
+        return this->impl->GetSize(out);
+    }
+
+    Result FileAccessor::OperateRange(void *dst, size_t dst_size, OperationId operation, s64 offset, s64 size, const void *src, size_t src_size) {
+        return this->impl->OperateRange(dst, dst_size, operation, offset, size, src, src_size);
+    }
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_file_accessor.hpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_file_accessor.hpp
@ -0,0 +1,68 @@
+/*
+ * 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 <stratosphere.hpp>
+
+namespace ams::fs::impl {
+
+    struct FilePathHash;
+    class FileSystemAccessor;
+
+    enum class WriteState {
+        None,
+        NeedsFlush,
+        Failed,
+    };
+
+    class FileAccessor : public util::IntrusiveListBaseNode<FileAccessor>, public Newable {
+        NON_COPYABLE(FileAccessor);
+        private:
+            std::unique_ptr<fsa::IFile> impl;
+            FileSystemAccessor * const parent;
+            WriteState write_state;
+            Result write_result;
+            const OpenMode open_mode;
+            std::unique_ptr<FilePathHash> file_path_hash;
+            s32 path_hash_index;
+        public:
+            FileAccessor(std::unique_ptr<fsa::IFile>&& f, FileSystemAccessor *p, OpenMode mode);
+            ~FileAccessor();
+
+            Result Read(size_t *out, s64 offset, void *buf, size_t size, const ReadOption &option);
+            Result Write(s64 offset, const void *buf, size_t size, const WriteOption &option);
+            Result Flush();
+            Result SetSize(s64 size);
+            Result GetSize(s64 *out);
+            Result OperateRange(void *dst, size_t dst_size, OperationId operation, s64 offset, s64 size, const void *src, size_t src_size);
+
+            OpenMode GetOpenMode() const { return this->open_mode; }
+            WriteState GetWriteState() const { return this->write_state; }
+            FileSystemAccessor *GetParent() const { return this->parent; }
+
+            void SetFilePathHash(std::unique_ptr<FilePathHash>&& file_path_hash, s32 index);
+            Result ReadWithoutCacheAccessLog(size_t *out, s64 offset, void *buf, size_t size, const ReadOption &option);
+        private:
+            Result ReadWithCacheAccessLog(size_t *out, s64 offset, void *buf, size_t size, const ReadOption &option, bool use_path_cache, bool use_data_cache);
+
+            ALWAYS_INLINE Result UpdateLastResult(Result r) {
+                if (!fs::ResultNotEnoughFreeSpace::Includes(r)) {
+                    this->write_result = r;
+                }
+                return r;
+            }
+    };
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_filesystem_accessor.cpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_filesystem_accessor.cpp
@ -0,0 +1,243 @@
+/*
+ * 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 <stratosphere.hpp>
+#include "fs_file_accessor.hpp"
+#include "fs_directory_accessor.hpp"
+#include "fs_filesystem_accessor.hpp"
+
+namespace ams::fs::impl {
+
+    namespace {
+
+        template<typename List, typename Iter>
+        void Remove(List &list, Iter *desired) {
+            for (auto it = list.cbegin(); it != list.cend(); it++) {
+                if (it.operator->() == desired) {
+                    list.erase(it);
+                    return;
+                }
+            }
+
+            /* This should never happen. */
+            AMS_ABORT();
+        }
+
+        Result ValidatePath(const char *mount_name, const char *path) {
+            const size_t mount_name_len = strnlen(mount_name, MountNameLengthMax);
+            const size_t path_len       = strnlen(path, EntryNameLengthMax);
+            R_UNLESS(mount_name_len + 1 + path_len <= EntryNameLengthMax, fs::ResultTooLongPath());
+
+            return ResultSuccess();
+        }
+
+        Result ValidateMountName(const char *name) {
+            R_UNLESS(name[0] != 0, fs::ResultInvalidMountName());
+            R_UNLESS(strnlen(name, sizeof(MountName)) < sizeof(MountName), fs::ResultInvalidMountName());
+            return ResultSuccess();
+        }
+
+        template<typename List>
+        Result ValidateNoOpenWriteModeFiles(List &list) {
+            for (auto it = list.cbegin(); it != list.cend(); it++) {
+                R_UNLESS((it->GetOpenMode() & OpenMode_Write) == 0, fs::ResultWriteModeFileNotClosed());
+            }
+            return ResultSuccess();
+        }
+
+    }
+
+    FileSystemAccessor::FileSystemAccessor(const char *n, std::unique_ptr<fsa::IFileSystem> &&fs, std::unique_ptr<fsa::ICommonMountNameGenerator> &&generator)
+        : impl(std::move(fs)), mount_name_generator(std::move(generator)),
+          access_log_enabled(false), data_cache_attachable(false), path_cache_attachable(false), path_cache_attached(false), multi_commit_supported(false)
+    {
+        R_ABORT_UNLESS(ValidateMountName(n));
+        std::strncpy(this->name.str, n, MountNameLengthMax);
+        this->name.str[MountNameLengthMax] = 0;
+    }
+
+    FileSystemAccessor::~FileSystemAccessor() {
+        std::scoped_lock lk(this->open_list_lock);
+
+        /* TODO: Iterate over list entries. */
+
+        if (!this->open_file_list.empty()) { R_ABORT_UNLESS(fs::ResultFileNotClosed()); }
+        if (!this->open_dir_list.empty()) { R_ABORT_UNLESS(fs::ResultDirectoryNotClosed()); }
+
+        if (this->path_cache_attached) {
+            /* TODO: Invalidate path cache */
+        }
+    }
+
+    Result FileSystemAccessor::GetCommonMountName(char *dst, size_t dst_size) const {
+        R_UNLESS(this->mount_name_generator != nullptr, fs::ResultPreconditionViolation());
+        return this->mount_name_generator->GenerateCommonMountName(dst, dst_size);
+    }
+
+    std::shared_ptr<fssrv::impl::FileSystemInterfaceAdapter> FileSystemAccessor::GetMultiCommitTarget() {
+        if (this->multi_commit_supported) {
+            /* TODO: Support multi commit. */
+            AMS_ABORT();
+        }
+        return nullptr;
+    }
+
+    void FileSystemAccessor::NotifyCloseFile(FileAccessor *f) {
+        std::scoped_lock lk(this->open_list_lock);
+        Remove(this->open_file_list, f);
+    }
+
+    void FileSystemAccessor::NotifyCloseDirectory(DirectoryAccessor *d) {
+        std::scoped_lock lk(this->open_list_lock);
+        Remove(this->open_dir_list, d);
+    }
+
+    Result FileSystemAccessor::CreateFile(const char *path, s64 size, int option) {
+        R_TRY(ValidatePath(this->name.str, path));
+        if (this->path_cache_attached) {
+            /* TODO: Path cache */
+            R_TRY(this->impl->CreateFile(path, size, option));
+        } else {
+            R_TRY(this->impl->CreateFile(path, size, option));
+        }
+        return ResultSuccess();
+    }
+
+    Result FileSystemAccessor::DeleteFile(const char *path) {
+        R_TRY(ValidatePath(this->name.str, path));
+        return this->impl->DeleteFile(path);
+    }
+
+    Result FileSystemAccessor::CreateDirectory(const char *path) {
+        R_TRY(ValidatePath(this->name.str, path));
+        return this->impl->CreateDirectory(path);
+    }
+
+    Result FileSystemAccessor::DeleteDirectory(const char *path) {
+        R_TRY(ValidatePath(this->name.str, path));
+        return this->impl->DeleteDirectory(path);
+    }
+
+    Result FileSystemAccessor::DeleteDirectoryRecursively(const char *path) {
+        R_TRY(ValidatePath(this->name.str, path));
+        return this->impl->DeleteDirectoryRecursively(path);
+    }
+
+    Result FileSystemAccessor::RenameFile(const char *old_path, const char *new_path) {
+        R_TRY(ValidatePath(this->name.str, old_path));
+        R_TRY(ValidatePath(this->name.str, new_path));
+        if (this->path_cache_attached) {
+            /* TODO: Path cache */
+            R_TRY(this->impl->RenameFile(old_path, new_path));
+        } else {
+            R_TRY(this->impl->RenameFile(old_path, new_path));
+        }
+        return ResultSuccess();
+    }
+
+    Result FileSystemAccessor::RenameDirectory(const char *old_path, const char *new_path) {
+        R_TRY(ValidatePath(this->name.str, old_path));
+        R_TRY(ValidatePath(this->name.str, new_path));
+        if (this->path_cache_attached) {
+            /* TODO: Path cache */
+            R_TRY(this->impl->RenameDirectory(old_path, new_path));
+        } else {
+            R_TRY(this->impl->RenameDirectory(old_path, new_path));
+        }
+        return ResultSuccess();
+    }
+
+    Result FileSystemAccessor::GetEntryType(DirectoryEntryType *out, const char *path) {
+        R_TRY(ValidatePath(this->name.str, path));
+        return this->impl->GetEntryType(out, path);
+    }
+
+    Result FileSystemAccessor::OpenFile(std::unique_ptr<FileAccessor> *out_file, const char *path, OpenMode mode) {
+        R_TRY(ValidatePath(this->name.str, path));
+
+        std::unique_ptr<fsa::IFile> file;
+        R_TRY(this->impl->OpenFile(std::addressof(file), path, mode));
+
+        auto accessor = new FileAccessor(std::move(file), this, mode);
+        R_UNLESS(accessor != nullptr, fs::ResultAllocationFailureInFileSystemAccessorA());
+
+        {
+            std::scoped_lock lk(this->open_list_lock);
+            this->open_file_list.push_back(*accessor);
+        }
+
+        if (this->path_cache_attached) {
+            if (mode & OpenMode_Append) {
+                /* TODO: Append Path cache */
+            } else {
+                /* TODO: Non-append path cache */
+            }
+        }
+
+        out_file->reset(accessor);
+        return ResultSuccess();
+    }
+
+    Result FileSystemAccessor::OpenDirectory(std::unique_ptr<DirectoryAccessor> *out_dir, const char *path, OpenDirectoryMode mode) {
+        R_TRY(ValidatePath(this->name.str, path));
+
+        std::unique_ptr<fsa::IDirectory> dir;
+        R_TRY(this->impl->OpenDirectory(std::addressof(dir), path, mode));
+
+        auto accessor = new DirectoryAccessor(std::move(dir), *this);
+        R_UNLESS(accessor != nullptr, fs::ResultAllocationFailureInFileSystemAccessorB());
+
+        {
+            std::scoped_lock lk(this->open_list_lock);
+            this->open_dir_list.push_back(*accessor);
+        }
+
+        out_dir->reset(accessor);
+        return ResultSuccess();
+    }
+
+    Result FileSystemAccessor::Commit() {
+        {
+            std::scoped_lock lk(this->open_list_lock);
+            R_ABORT_UNLESS(ValidateNoOpenWriteModeFiles(this->open_file_list));
+        }
+        return this->impl->Commit();
+    }
+
+    Result FileSystemAccessor::GetFreeSpaceSize(s64 *out, const char *path) {
+        R_TRY(ValidatePath(this->name.str, path));
+        return this->impl->GetFreeSpaceSize(out, path);
+    }
+
+    Result FileSystemAccessor::GetTotalSpaceSize(s64 *out, const char *path) {
+        R_TRY(ValidatePath(this->name.str, path));
+        return this->impl->GetTotalSpaceSize(out, path);
+    }
+
+    Result FileSystemAccessor::CleanDirectoryRecursively(const char *path) {
+        R_TRY(ValidatePath(this->name.str, path));
+        return this->impl->CleanDirectoryRecursively(path);
+    }
+
+    Result FileSystemAccessor::GetFileTimeStampRaw(FileTimeStampRaw *out, const char *path) {
+        return this->impl->GetFileTimeStampRaw(out, path);
+    }
+
+    Result FileSystemAccessor::QueryEntry(char *dst, size_t dst_size, const char *src, size_t src_size, fsa::QueryId query, const char *path) {
+        return this->impl->QueryEntry(dst, dst_size, src, src_size, query, path);
+    }
+
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_filesystem_accessor.hpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_filesystem_accessor.hpp
@ -0,0 +1,94 @@
+/*
+ * 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 <stratosphere.hpp>
+#include <stratosphere/fssrv/fssrv_interface_adapters.hpp>
+#include "fs_mount_name.hpp"
+
+namespace ams::fs::impl {
+
+    class FileAccessor;
+    class DirectoryAccessor;
+
+    class FileSystemAccessor : public util::IntrusiveListBaseNode<FileSystemAccessor>,  public Newable {
+        NON_COPYABLE(FileSystemAccessor);
+        friend class FileAccessor;
+        friend class DirectoryAccessor;
+        private:
+            using FileList = util::IntrusiveListBaseTraits<FileAccessor>::ListType;
+            using DirList  = util::IntrusiveListBaseTraits<DirectoryAccessor>::ListType;
+        private:
+            MountName name;
+            std::unique_ptr<fsa::IFileSystem> impl;
+            FileList open_file_list;
+            DirList open_dir_list;
+            os::Mutex open_list_lock;
+            std::unique_ptr<fsa::ICommonMountNameGenerator> mount_name_generator;
+            bool access_log_enabled;
+            bool data_cache_attachable;
+            bool path_cache_attachable;
+            bool path_cache_attached;
+            bool multi_commit_supported;
+        public:
+            FileSystemAccessor(const char *name, std::unique_ptr<fsa::IFileSystem> &&fs, std::unique_ptr<fsa::ICommonMountNameGenerator> &&generator = nullptr);
+            virtual ~FileSystemAccessor();
+
+            Result CreateFile(const char *path, s64 size, int option);
+            Result DeleteFile(const char *path);
+            Result CreateDirectory(const char *path);
+            Result DeleteDirectory(const char *path);
+            Result DeleteDirectoryRecursively(const char *path);
+            Result RenameFile(const char *old_path, const char *new_path);
+            Result RenameDirectory(const char *old_path, const char *new_path);
+            Result GetEntryType(DirectoryEntryType *out, const char *path);
+            Result OpenFile(std::unique_ptr<FileAccessor> *out_file, const char *path, OpenMode mode);
+            Result OpenDirectory(std::unique_ptr<DirectoryAccessor> *out_dir, const char *path, OpenDirectoryMode mode);
+            Result Commit();
+            Result GetFreeSpaceSize(s64 *out, const char *path);
+            Result GetTotalSpaceSize(s64 *out, const char *path);
+            Result CleanDirectoryRecursively(const char *path);
+            Result GetFileTimeStampRaw(FileTimeStampRaw *out, const char *path);
+            Result QueryEntry(char *dst, size_t dst_size, const char *src, size_t src_size, fsa::QueryId query, const char *path);
+
+            const char *GetName() const { return this->name.str; }
+            Result GetCommonMountName(char *dst, size_t dst_size) const;
+
+            void SetAccessLogEnabled(bool en) { this->access_log_enabled = en; }
+            void SetFileDataCacheAttachable(bool en) { this->data_cache_attachable = en; }
+            void SetPathBasedFileDataCacheAttachable(bool en) { this->path_cache_attachable = en; }
+            void SetMultiCommitSupported(bool en) { this->multi_commit_supported = en; }
+
+            bool IsAccessLogEnabled() const { return this->access_log_enabled; }
+            bool IsFileDataCacheAttachable() const { return this->data_cache_attachable; }
+            bool IsPathBasedFileDataCacheAttachable() const { return this->path_cache_attachable; }
+
+            void AttachPathBasedFileDataCache() {
+                if (this->IsPathBasedFileDataCacheAttachable()) {
+                    this->path_cache_attached = true;
+                }
+            }
+
+            void DetachPathBasedFileDataCache() {
+                this->path_cache_attached = false;
+            }
+
+            std::shared_ptr<fssrv::impl::FileSystemInterfaceAdapter> GetMultiCommitTarget();
+        private:
+            void NotifyCloseFile(FileAccessor *f);
+            void NotifyCloseDirectory(DirectoryAccessor *d);
+    };
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_mount_name.hpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_mount_name.hpp
@ -0,0 +1,26 @@
+/*
+ * 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 <stratosphere.hpp>
+
+namespace ams::fs {
+
+    struct MountName {
+        char str[MountNameLengthMax + 1];
+    };
+    static_assert(std::is_pod<MountName>::value);
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_mount_table.cpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_mount_table.cpp
@ -0,0 +1,75 @@
+/*
+ * 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 <stratosphere.hpp>
+#include "fs_mount_table.hpp"
+
+namespace ams::fs::impl {
+
+    namespace {
+
+        bool MatchesName(const FileSystemAccessor &accessor, const char *name) {
+            return std::strncmp(accessor.GetName(), name, sizeof(MountName)) == 0;
+        }
+
+    }
+
+    bool MountTable::CanAcceptMountName(const char *name) {
+        for (const auto &fs : this->fs_list) {
+            if (MatchesName(fs, name)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    Result MountTable::Mount(std::unique_ptr<FileSystemAccessor> &&fs) {
+        std::scoped_lock lk(this->mutex);
+
+        R_UNLESS(this->CanAcceptMountName(fs->GetName()), fs::ResultMountNameAlreadyExists());
+
+        this->fs_list.push_back(*fs.release());
+        return ResultSuccess();
+    }
+
+    Result MountTable::Find(FileSystemAccessor **out, const char *name) {
+        std::scoped_lock lk(this->mutex);
+
+        for (auto &fs : this->fs_list) {
+            if (MatchesName(fs, name)) {
+                *out = std::addressof(fs);
+                return ResultSuccess();
+            }
+        }
+
+        return fs::ResultNotMounted();
+    }
+
+    void MountTable::Unmount(const char *name) {
+        std::scoped_lock lk(this->mutex);
+
+        for (auto it = this->fs_list.cbegin(); it != this->fs_list.cend(); it++) {
+            if (MatchesName(*it, name)) {
+                auto p = std::addressof(*it);
+                this->fs_list.erase(it);
+                delete p;
+                return;
+            }
+        }
+
+        R_ABORT_UNLESS(fs::ResultNotMounted());
+    }
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_mount_table.hpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_mount_table.hpp
@ -0,0 +1,40 @@
+/*
+ * 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 <stratosphere.hpp>
+#include "fs_filesystem_accessor.hpp"
+
+namespace ams::fs::impl {
+
+    class MountTable : public Newable {
+        NON_COPYABLE(MountTable);
+        NON_MOVEABLE(MountTable);
+        private:
+            using FileSystemList = util::IntrusiveListBaseTraits<FileSystemAccessor>::ListType;
+        private:
+            FileSystemList fs_list;
+            os::Mutex mutex;
+        public:
+            constexpr MountTable() : fs_list(), mutex() { /* ... */ }
+        private:
+            bool CanAcceptMountName(const char *name);
+        public:
+            Result Mount(std::unique_ptr<FileSystemAccessor> &&fs);
+            Result Find(FileSystemAccessor **out, const char *name);
+            void Unmount(const char *name);
+    };
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_mount_utils.cpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_mount_utils.cpp
@ -0,0 +1,168 @@
+/*
+ * 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 <stratosphere.hpp>
+#include "fs_filesystem_accessor.hpp"
+#include "fs_mount_utils.hpp"
+#include "fs_user_mount_table.hpp"
+
+namespace ams::fs::impl {
+
+    namespace {
+
+        const char *FindMountNameDriveSeparator(const char *path) {
+            for (const char *cur = path; cur < path + MountNameLengthMax + 1; cur++) {
+                if (PathTool::IsDriveSeparator(*cur)) {
+                    return cur;
+                } else if (PathTool::IsNullTerminator(*cur)) {
+                    break;
+                }
+            }
+            return nullptr;
+        }
+
+        Result GetMountNameAndSubPath(MountName *out_mount_name, const char **out_sub_path, const char *path) {
+            /* Handle the Host-path case. */
+            if (PathTool::IsWindowsAbsolutePath(path) || PathTool::IsUnc(path)) {
+                std::strncpy(out_mount_name->str, HostRootFileSystemMountName, MountNameLengthMax);
+                out_mount_name->str[MountNameLengthMax] = '\x00';
+                return ResultSuccess();
+            }
+
+            /* Locate the drive separator. */
+            const char *drive_separator = FindMountNameDriveSeparator(path);
+            R_UNLESS(drive_separator != nullptr, fs::ResultInvalidMountName());
+
+            /* Ensure the mount name isn't too long. */
+            const size_t len = drive_separator - path;
+            R_UNLESS(len <= MountNameLengthMax, fs::ResultInvalidMountName());
+
+            /* Ensure the result sub-path is valid. */
+            const char *sub_path = drive_separator + 1;
+            R_UNLESS(!PathTool::IsNullTerminator(sub_path[0]), fs::ResultInvalidMountName());
+            R_UNLESS(PathTool::IsAnySeparator(sub_path[0]),    fs::ResultInvalidPathFormat());
+
+            /* Set output. */
+            std::memcpy(out_mount_name->str, path, len);
+            out_mount_name->str[len] = StringTraits::NullTerminator;
+            *out_sub_path = sub_path;
+            return ResultSuccess();
+        }
+
+    }
+
+    bool IsValidMountName(const char *name) {
+        if (PathTool::IsNullTerminator(*name)) {
+            return false;
+        }
+
+        if (PathTool::IsWindowsDriveCharacter(name[0]) && PathTool::IsNullTerminator(name[1])) {
+            return false;
+        }
+
+        size_t len = 0;
+        for (const char *cur = name; !PathTool::IsNullTerminator(*cur); cur++) {
+            if (PathTool::IsDriveSeparator(*cur) || PathTool::IsSeparator(*cur)) {
+                return false;
+            }
+
+            if ((++len) > MountNameLengthMax) {
+                return false;
+            }
+        }
+
+        /* TODO: N validates that the mount name decodes via utf-8 here. */
+        return true;
+    }
+
+    bool IsWindowsDrive(const char *name) {
+        return PathTool::IsWindowsAbsolutePath(name);
+    }
+
+    bool IsReservedMountName(const char *name) {
+        return name[0] == ReservedMountNamePrefixCharacter;
+    }
+
+    Result CheckMountName(const char *name) {
+        R_TRY(CheckMountNameAllowingReserved(name));
+        R_UNLESS(!impl::IsReservedMountName(name), fs::ResultInvalidMountName());
+        return ResultSuccess();
+    }
+
+    Result CheckMountNameAllowingReserved(const char *name) {
+        R_UNLESS(name != nullptr,              fs::ResultInvalidMountName());
+        R_UNLESS(impl::IsValidMountName(name), fs::ResultInvalidMountName());
+        return ResultSuccess();
+    }
+
+    Result FindFileSystem(FileSystemAccessor **out_accessor, const char **out_sub_path, const char *path) {
+        R_UNLESS(out_accessor != nullptr, fs::ResultUnexpectedInFindFileSystemA());
+        R_UNLESS(out_sub_path != nullptr, fs::ResultUnexpectedInFindFileSystemA());
+        R_UNLESS(path != nullptr,         fs::ResultNullptrArgument());
+
+        R_UNLESS(strncmp(path, HostRootFileSystemMountName, strnlen(HostRootFileSystemMountName, sizeof(MountName))) != 0, fs::ResultNotMounted());
+
+        MountName mount_name;
+        R_TRY(GetMountNameAndSubPath(std::addressof(mount_name), out_sub_path, path));
+
+        return impl::Find(out_accessor, mount_name.str);
+    }
+
+}
+
+namespace ams::fs {
+
+    namespace {
+
+        Result UnmountImpl(const char *name) {
+            impl::FileSystemAccessor *accessor;
+            R_TRY(impl::Find(std::addressof(accessor), name));
+
+            if (accessor->IsFileDataCacheAttachable()) {
+                /* TODO: Data cache purge */
+            }
+
+            impl::Unregister(name);
+            return ResultSuccess();
+        }
+
+    }
+
+    Result ConvertToFsCommonPath(char *dst, size_t dst_size, const char *src) {
+        /* Ensure neither argument is nullptr. */
+        R_UNLESS(dst != nullptr, fs::ResultNullptrArgument());
+        R_UNLESS(src != nullptr, fs::ResultNullptrArgument());
+
+        /* Get the mount name and sub path for the path. */
+        MountName mount_name;
+        const char *sub_path;
+        R_TRY(impl::GetMountNameAndSubPath(std::addressof(mount_name), std::addressof(sub_path), src));
+
+        impl::FileSystemAccessor *accessor;
+        R_TRY(impl::Find(std::addressof(accessor), mount_name.str));
+        R_TRY(accessor->GetCommonMountName(dst, dst_size));
+
+        const auto mount_name_len = strnlen(dst, dst_size);
+        const auto common_path_len = std::snprintf(dst + mount_name_len, dst_size - mount_name_len, "%s", sub_path);
+
+        R_UNLESS(static_cast<size_t>(common_path_len) < dst_size - mount_name_len, fs::ResultTooLongPath());
+        return ResultSuccess();
+    }
+
+    void Unmount(const char *mount_name) {
+        R_ABORT_UNLESS(UnmountImpl(mount_name));
+    }
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_mount_utils.hpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_mount_utils.hpp
@ -0,0 +1,30 @@
+/*
+ * 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 <stratosphere.hpp>
+
+namespace ams::fs::impl {
+
+    class FileSystemAccessor;
+
+    Result FindFileSystem(FileSystemAccessor **out_accessor, const char **out_sub_path, const char *path);
+
+    bool IsWindowsDrive(const char *name);
+    bool IsReservedMountName(const char *name);
+    Result CheckMountName(const char *name);
+    Result CheckMountNameAllowingReserved(const char *name);
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_registrar.cpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_registrar.cpp
@ -0,0 +1,51 @@
+/*
+ * 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 <stratosphere.hpp>
+#include "fs_filesystem_accessor.hpp"
+#include "fs_user_mount_table.hpp"
+
+namespace ams::fs::fsa {
+
+    Result Register(const char *name, std::unique_ptr<IFileSystem> &&fs) {
+        auto accessor = std::make_unique<impl::FileSystemAccessor>(name, std::move(fs));
+        R_UNLESS(accessor != nullptr, fs::ResultAllocationFailureInRegisterA());
+
+        return impl::Register(std::move(accessor));
+    }
+
+    Result Register(const char *name, std::unique_ptr<IFileSystem> &&fs, std::unique_ptr<ICommonMountNameGenerator> &&generator) {
+        auto accessor = std::make_unique<impl::FileSystemAccessor>(name, std::move(fs), std::move(generator));
+        R_UNLESS(accessor != nullptr, fs::ResultAllocationFailureInRegisterB());
+
+        return impl::Register(std::move(accessor));
+    }
+
+    Result Register(const char *name, std::unique_ptr<IFileSystem> &&fs, std::unique_ptr<ICommonMountNameGenerator> &&generator, bool use_data_cache, bool use_path_cache, bool support_multi_commit) {
+        auto accessor = std::make_unique<impl::FileSystemAccessor>(name, std::move(fs), std::move(generator));
+        R_UNLESS(accessor != nullptr, fs::ResultAllocationFailureInRegisterB());
+
+        accessor->SetFileDataCacheAttachable(use_data_cache);
+        accessor->SetPathBasedFileDataCacheAttachable(use_path_cache);
+        accessor->SetMultiCommitSupported(support_multi_commit);
+
+        return impl::Register(std::move(accessor));
+    }
+
+    void Unregister(const char *name) {
+        impl::Unregister(name);
+    }
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_user_directory.cpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_user_directory.cpp
@ -0,0 +1,42 @@
+/*
+ * 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 <stratosphere.hpp>
+#include "fs_directory_accessor.hpp"
+#include "fs_filesystem_accessor.hpp"
+
+namespace ams::fs {
+
+    namespace {
+
+        ALWAYS_INLINE impl::DirectoryAccessor *Get(DirectoryHandle handle) {
+            return reinterpret_cast<impl::DirectoryAccessor *>(handle.handle);
+        }
+
+    }
+
+    Result ReadDirectory(s64 *out_count, DirectoryEntry *out_entries, DirectoryHandle handle, s64 max_entries) {
+        return Get(handle)->Read(out_count, out_entries, max_entries);
+    }
+
+    Result GetDirectoryEntryCount(s64 *out, DirectoryHandle handle) {
+        return Get(handle)->GetEntryCount(out);
+    }
+
+    void CloseDirectory(DirectoryHandle handle) {
+        delete Get(handle);
+    }
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_user_file.cpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_user_file.cpp
@ -0,0 +1,77 @@
+/*
+ * 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 <stratosphere.hpp>
+#include "fs_file_accessor.hpp"
+#include "fs_filesystem_accessor.hpp"
+
+namespace ams::fs {
+
+    namespace {
+
+        ALWAYS_INLINE impl::FileAccessor *Get(FileHandle handle) {
+            return reinterpret_cast<impl::FileAccessor *>(handle.handle);
+        }
+
+    }
+
+    Result ReadFile(FileHandle handle, s64 offset, void *buffer, size_t size, const fs::ReadOption &option) {
+        size_t read_size;
+        R_TRY(ReadFile(std::addressof(read_size), handle, offset, buffer, size, option));
+        R_UNLESS(read_size == size, fs::ResultOutOfRange());
+        return ResultSuccess();
+    }
+
+    Result ReadFile(FileHandle handle, s64 offset, void *buffer, size_t size) {
+        return ReadFile(handle, offset, buffer, size, ReadOption());
+    }
+
+    Result ReadFile(size_t *out, FileHandle handle, s64 offset, void *buffer, size_t size, const fs::ReadOption &option) {
+        return Get(handle)->Read(out, offset, buffer, size, option);
+    }
+
+    Result ReadFile(size_t *out, FileHandle handle, s64 offset, void *buffer, size_t size) {
+        return ReadFile(out, handle, offset, buffer, size, ReadOption());
+    }
+
+    Result GetFileSize(s64 *out, FileHandle handle) {
+        return Get(handle)->GetSize(out);
+    }
+
+    Result FlushFile(FileHandle handle) {
+        return Get(handle)->Flush();
+    }
+
+    Result WriteFile(FileHandle handle, s64 offset, const void *buffer, size_t size, const fs::WriteOption &option) {
+        return Get(handle)->Write(offset, buffer, size, option);
+    }
+
+    Result SetFileSize(FileHandle handle, s64 size) {
+        return Get(handle)->SetSize(size);
+    }
+
+    int GetFileOpenMode(FileHandle handle) {
+        return Get(handle)->GetOpenMode();
+    }
+
+    void CloseFile(FileHandle handle) {
+        delete Get(handle);
+    }
+
+    Result QueryRange(QueryRangeInfo *out, FileHandle handle, s64 offset, s64 size) {
+        return Get(handle)->OperateRange(out, sizeof(*out), OperationId::QueryRange, offset, size, nullptr, 0);
+    }
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_user_filesystem.cpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_user_filesystem.cpp
@ -0,0 +1,199 @@
+/*
+ * 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 <stratosphere.hpp>
+#include "fs_filesystem_accessor.hpp"
+#include "fs_file_accessor.hpp"
+#include "fs_directory_accessor.hpp"
+#include "fs_mount_utils.hpp"
+#include "fs_user_mount_table.hpp"
+
+namespace ams::fs {
+
+    Result CreateFile(const char *path, s64 size) {
+        return CreateFile(path, size, 0);
+    }
+
+    Result CreateFile(const char* path, s64 size, int option) {
+        impl::FileSystemAccessor *accessor;
+        const char *sub_path;
+        R_TRY(impl::FindFileSystem(std::addressof(accessor), std::addressof(sub_path), path));
+
+        return accessor->CreateFile(sub_path, size, option);
+    }
+
+    Result DeleteFile(const char *path) {
+        impl::FileSystemAccessor *accessor;
+        const char *sub_path;
+        R_TRY(impl::FindFileSystem(std::addressof(accessor), std::addressof(sub_path), path));
+
+        return accessor->DeleteFile(sub_path);
+    }
+
+    Result CreateDirectory(const char *path) {
+        impl::FileSystemAccessor *accessor;
+        const char *sub_path;
+        R_TRY(impl::FindFileSystem(std::addressof(accessor), std::addressof(sub_path), path));
+
+        return accessor->CreateDirectory(sub_path);
+    }
+
+    Result DeleteDirectory(const char *path) {
+        impl::FileSystemAccessor *accessor;
+        const char *sub_path;
+        R_TRY(impl::FindFileSystem(std::addressof(accessor), std::addressof(sub_path), path));
+
+        return accessor->DeleteDirectory(sub_path);
+    }
+
+    Result DeleteDirectoryRecursively(const char *path) {
+        impl::FileSystemAccessor *accessor;
+        const char *sub_path;
+        R_TRY(impl::FindFileSystem(std::addressof(accessor), std::addressof(sub_path), path));
+
+        return accessor->DeleteDirectoryRecursively(sub_path);
+    }
+
+    Result RenameFile(const char *old_path, const char *new_path) {
+        impl::FileSystemAccessor *old_accessor;
+        impl::FileSystemAccessor *new_accessor;
+        const char *old_sub_path;
+        const char *new_sub_path;
+        R_TRY(impl::FindFileSystem(std::addressof(old_accessor), std::addressof(old_sub_path), old_path));
+        R_TRY(impl::FindFileSystem(std::addressof(new_accessor), std::addressof(new_sub_path), new_path));
+
+        R_UNLESS(old_accessor == new_accessor, fs::ResultRenameToOtherFileSystem());
+        return old_accessor->RenameFile(old_sub_path, new_sub_path);
+    }
+
+    Result RenameDirectory(const char *old_path, const char *new_path) {
+        impl::FileSystemAccessor *old_accessor;
+        impl::FileSystemAccessor *new_accessor;
+        const char *old_sub_path;
+        const char *new_sub_path;
+        R_TRY(impl::FindFileSystem(std::addressof(old_accessor), std::addressof(old_sub_path), old_path));
+        R_TRY(impl::FindFileSystem(std::addressof(new_accessor), std::addressof(new_sub_path), new_path));
+
+        R_UNLESS(old_accessor == new_accessor, fs::ResultRenameToOtherFileSystem());
+        return old_accessor->RenameDirectory(old_sub_path, new_sub_path);
+    }
+
+    Result GetEntryType(DirectoryEntryType *out, const char *path) {
+        impl::FileSystemAccessor *accessor;
+        const char *sub_path;
+        R_TRY(impl::FindFileSystem(std::addressof(accessor), std::addressof(sub_path), path));
+
+        return accessor->GetEntryType(out, sub_path);
+    }
+
+    Result OpenFile(FileHandle *out_file, const char *path, int mode) {
+        impl::FileSystemAccessor *accessor;
+        const char *sub_path;
+        R_TRY(impl::FindFileSystem(std::addressof(accessor), std::addressof(sub_path), path));
+
+        R_UNLESS(out_file != nullptr, fs::ResultNullptrArgument());
+
+        std::unique_ptr<impl::FileAccessor> file_accessor;
+        R_TRY(accessor->OpenFile(std::addressof(file_accessor), sub_path, static_cast<OpenMode>(mode)));
+
+        out_file->handle = file_accessor.release();
+        return ResultSuccess();
+    }
+
+    Result OpenDirectory(DirectoryHandle *out_dir, const char *path, int mode) {
+        impl::FileSystemAccessor *accessor;
+        const char *sub_path;
+        R_TRY(impl::FindFileSystem(std::addressof(accessor), std::addressof(sub_path), path));
+
+        R_UNLESS(out_dir != nullptr, fs::ResultNullptrArgument());
+
+        std::unique_ptr<impl::DirectoryAccessor> dir_accessor;
+        R_TRY(accessor->OpenDirectory(std::addressof(dir_accessor), sub_path, static_cast<OpenDirectoryMode>(mode)));
+
+        out_dir->handle = dir_accessor.release();
+        return ResultSuccess();
+    }
+
+    Result CleanDirectoryRecursively(const char *path) {
+        impl::FileSystemAccessor *accessor;
+        const char *sub_path;
+        R_TRY(impl::FindFileSystem(std::addressof(accessor), std::addressof(sub_path), path));
+
+        return accessor->CleanDirectoryRecursively(sub_path);
+    }
+
+    Result GetFreeSpaceSize(s64 *out, const char *path) {
+        impl::FileSystemAccessor *accessor;
+        const char *sub_path;
+        R_TRY(impl::FindFileSystem(std::addressof(accessor), std::addressof(sub_path), path));
+
+        return accessor->GetFreeSpaceSize(out, sub_path);
+    }
+
+    Result GetTotalSpaceSize(s64 *out, const char *path) {
+        impl::FileSystemAccessor *accessor;
+        const char *sub_path;
+        R_TRY(impl::FindFileSystem(std::addressof(accessor), std::addressof(sub_path), path));
+
+        return accessor->GetTotalSpaceSize(out, sub_path);
+    }
+
+    Result SetConcatenationFileAttribute(const char *path) {
+        impl::FileSystemAccessor *accessor;
+        const char *sub_path;
+        R_TRY(impl::FindFileSystem(std::addressof(accessor), std::addressof(sub_path), path));
+
+        return accessor->QueryEntry(nullptr, 0, nullptr, 0, fsa::QueryId::SetConcatenationFileAttribute, sub_path);
+    }
+
+    Result GetFileTimeStampRaw(FileTimeStampRaw *out, const char *path) {
+        impl::FileSystemAccessor *accessor;
+        const char *sub_path;
+        R_TRY(impl::FindFileSystem(std::addressof(accessor), std::addressof(sub_path), path));
+
+        return accessor->GetFileTimeStampRaw(out, sub_path);
+    }
+
+    Result OpenFile(FileHandle *out, std::unique_ptr<fsa::IFile> &&file, int mode) {
+        R_UNLESS(out != nullptr, fs::ResultNullptrArgument());
+
+        auto file_accessor = std::make_unique<impl::FileAccessor>(std::move(file), nullptr, static_cast<OpenMode>(mode));
+        R_UNLESS(file_accessor != nullptr, fs::ResultAllocationFailureInNew());
+        out->handle = file_accessor.release();
+
+        return ResultSuccess();
+    }
+
+    namespace {
+
+        Result CommitImpl(const char *path) {
+            impl::FileSystemAccessor *accessor;
+            R_TRY(impl::Find(std::addressof(accessor), path));
+
+            return accessor->Commit();
+        }
+
+    }
+
+    Result Commit(const char *path) {
+        return CommitImpl(path);
+    }
+
+    Result CommitSaveData(const char *path) {
+        return CommitImpl(path);
+    }
+
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_user_mount_table.cpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_user_mount_table.cpp
@ -0,0 +1,41 @@
+/*
+ * 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 <stratosphere.hpp>
+#include "fs_user_mount_table.hpp"
+#include "fs_mount_table.hpp"
+#include "fs_filesystem_accessor.hpp"
+
+namespace ams::fs::impl {
+
+    namespace {
+
+        MountTable g_mount_table;
+
+    }
+
+    Result Register(std::unique_ptr<FileSystemAccessor> &&fs) {
+        return g_mount_table.Mount(std::move(fs));
+    }
+
+    Result Find(FileSystemAccessor **out, const char *name) {
+        return g_mount_table.Find(out,  name);
+    }
+
+    void Unregister(const char *name) {
+        g_mount_table.Unmount(name);
+    }
+
+}
--- a/libraries/libstratosphere/source/fs/fsa/fs_user_mount_table.hpp
+++ b/libraries/libstratosphere/source/fs/fsa/fs_user_mount_table.hpp
@ -0,0 +1,27 @@
+/*
+ * 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 <stratosphere.hpp>
+
+namespace ams::fs::impl {
+
+    class FileSystemAccessor;
+
+    Result Register(std::unique_ptr<FileSystemAccessor> &&fs);
+    Result Find(FileSystemAccessor **out, const char *name);
+    void Unregister(const char *name);
+
+}