git subrepo clone https://github.com/Atmosphere-NX/Atmosphere-libs libraries

subrepo:
  subdir:   "libraries"
  merged:   "07af583b"
upstream:
  origin:   "https://github.com/Atmosphere-NX/Atmosphere-libs"
  branch:   "master"
  commit:   "07af583b"
git-subrepo:
  version:  "0.4.0"
  origin:   "https://github.com/ingydotnet/git-subrepo"
  commit:   "5d6aba9"

libraries/libstratosphere/source/fssystem/fssystem_directory_redirection_filesystem.cpp

@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2018-2019 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>
+
+namespace ams::fssystem {
+
+    DirectoryRedirectionFileSystem::DirectoryRedirectionFileSystem(std::shared_ptr<fs::fsa::IFileSystem> fs, const char *before, const char *after, bool unc)
+        : PathResolutionFileSystem(fs, unc)
+    {
+        this->before_dir = nullptr;
+        this->after_dir = nullptr;
+        R_ASSERT(this->Initialize(before, after));
+    }
+
+    DirectoryRedirectionFileSystem::DirectoryRedirectionFileSystem(std::unique_ptr<fs::fsa::IFileSystem> fs, const char *before, const char *after, bool unc)
+        : PathResolutionFileSystem(std::move(fs), unc)
+    {
+        this->before_dir = nullptr;
+        this->after_dir = nullptr;
+        R_ASSERT(this->Initialize(before, after));
+    }
+
+    DirectoryRedirectionFileSystem::~DirectoryRedirectionFileSystem() {
+        if (this->before_dir != nullptr) {
+            std::free(this->before_dir);
+        }
+        if (this->after_dir != nullptr) {
+            std::free(this->after_dir);
+        }
+    }
+
+    Result DirectoryRedirectionFileSystem::GetNormalizedDirectoryPath(char **out, size_t *out_size, const char *dir) {
+        /* Clear output. */
+        *out = nullptr;
+        *out_size = 0;
+
+        /* Make sure the path isn't too long. */
+        R_UNLESS(strnlen(dir, fs::EntryNameLengthMax + 1) <= fs::EntryNameLengthMax, fs::ResultTooLongPath());
+
+        /* Normalize the path. */
+        char normalized_path[fs::EntryNameLengthMax + 2];
+        size_t normalized_path_len;
+        R_TRY(PathTool::Normalize(normalized_path, &normalized_path_len, dir, sizeof(normalized_path), this->IsUncPreserved()));
+
+        /* Ensure terminating '/' */
+        if (!PathTool::IsSeparator(normalized_path[normalized_path_len - 1])) {
+            AMS_ASSERT(normalized_path_len + 2 <= sizeof(normalized_path));
+            normalized_path[normalized_path_len]     = StringTraits::DirectorySeparator;
+            normalized_path[normalized_path_len + 1] = StringTraits::NullTerminator;
+
+            normalized_path_len++;
+        }
+
+        /* Allocate new path. */
+        const size_t size = normalized_path_len + 1;
+        char *new_dir = static_cast<char *>(std::malloc(size));
+        AMS_ASSERT(new_dir != nullptr);
+        /* TODO: custom ResultAllocationFailure? */
+
+        /* Copy path in. */
+        std::memcpy(new_dir, normalized_path, normalized_path_len);
+        new_dir[normalized_path_len] = StringTraits::NullTerminator;
+
+        /* Set output. */
+        *out = new_dir;
+        *out_size = size;
+        return ResultSuccess();
+    }
+
+    Result DirectoryRedirectionFileSystem::Initialize(const char *before, const char *after) {
+        /* Normalize both directories. */
+        this->GetNormalizedDirectoryPath(&this->before_dir, &this->before_dir_len, before);
+        this->GetNormalizedDirectoryPath(&this->after_dir, &this->after_dir_len, after);
+
+        return ResultSuccess();
+    }
+
+    Result DirectoryRedirectionFileSystem::ResolveFullPath(char *out, size_t out_size, const char *relative_path) {
+        /* Normalize the relative path. */
+        char normalized_rel_path[fs::EntryNameLengthMax + 1];
+        size_t normalized_rel_path_len;
+        R_TRY(PathTool::Normalize(normalized_rel_path, &normalized_rel_path_len, relative_path, sizeof(normalized_rel_path), this->IsUncPreserved()));
+
+        const bool is_prefixed = std::memcmp(normalized_rel_path, this->before_dir, this->before_dir_len - 2) == 0 &&
+                                 (PathTool::IsSeparator(normalized_rel_path[this->before_dir_len - 2]) || PathTool::IsNullTerminator(normalized_rel_path[this->before_dir_len - 2]));
+        if (is_prefixed) {
+            const size_t before_prefix_len = this->before_dir_len - 2;
+            const size_t after_prefix_len  = this->after_dir_len - 2;
+            const size_t final_str_len = after_prefix_len + normalized_rel_path_len - before_prefix_len;
+            R_UNLESS(final_str_len < out_size, fs::ResultTooLongPath());
+
+            /* Copy normalized path. */
+            std::memcpy(out, this->after_dir, after_prefix_len);
+            std::memcpy(out + after_prefix_len, normalized_rel_path + before_prefix_len, normalized_rel_path_len - before_prefix_len);
+            out[final_str_len] = StringTraits::NullTerminator;
+        } else {
+            /* Path is not prefixed. */
+            R_UNLESS(normalized_rel_path_len + 1 <= out_size, fs::ResultTooLongPath());
+            std::memcpy(out, normalized_rel_path, normalized_rel_path_len);
+            out[normalized_rel_path_len] = StringTraits::NullTerminator;
+        }
+
+        return ResultSuccess();
+    }
+
+}

libraries/libstratosphere/source/fssystem/fssystem_directory_savedata_filesystem.cpp

@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) 2018-2019 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>
+
+namespace ams::fssystem {
+
+    namespace {
+
+        constexpr size_t IdealWorkBufferSize = 0x100000; /* 1 MiB */
+
+        constexpr const char CommittedDirectoryPath[]     = "/0/";
+        constexpr const char WorkingDirectoryPath[]       = "/1/";
+        constexpr const char SynchronizingDirectoryPath[] = "/_/";
+
+        class DirectorySaveDataFile : public fs::fsa::IFile {
+            private:
+                std::unique_ptr<fs::fsa::IFile> base_file;
+                DirectorySaveDataFileSystem *parent_fs;
+                fs::OpenMode open_mode;
+            public:
+                DirectorySaveDataFile(std::unique_ptr<fs::fsa::IFile> f, DirectorySaveDataFileSystem *p, fs::OpenMode m) : base_file(std::move(f)), parent_fs(p), open_mode(m) {
+                    /* ... */
+                }
+
+                virtual ~DirectorySaveDataFile() {
+                    /* Observe closing of writable file. */
+                    if (this->open_mode & fs::OpenMode_Write) {
+                        this->parent_fs->OnWritableFileClose();
+                    }
+                }
+            public:
+                virtual Result ReadImpl(size_t *out, s64 offset, void *buffer, size_t size, const fs::ReadOption &option) override {
+                    return this->base_file->Read(out, offset, buffer, size, option);
+                }
+
+                virtual Result GetSizeImpl(s64 *out) override {
+                    return this->base_file->GetSize(out);
+                }
+
+                virtual Result FlushImpl() override {
+                    return this->base_file->Flush();
+                }
+
+                virtual Result WriteImpl(s64 offset, const void *buffer, size_t size, const fs::WriteOption &option) override {
+                    return this->base_file->Write(offset, buffer, size, option);
+                }
+
+                virtual Result SetSizeImpl(s64 size) override {
+                    return this->base_file->SetSize(size);
+                }
+
+                virtual Result OperateRangeImpl(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override {
+                    return this->base_file->OperateRange(dst, dst_size, op_id, offset, size, src, src_size);
+                }
+            public:
+                virtual sf::cmif::DomainObjectId GetDomainObjectId() const override {
+                    return this->base_file->GetDomainObjectId();
+                }
+        };
+
+    }
+
+    DirectorySaveDataFileSystem::DirectorySaveDataFileSystem(std::shared_ptr<fs::fsa::IFileSystem> fs)
+        : PathResolutionFileSystem(fs), open_writable_files(0)
+    {
+        /* ... */
+    }
+
+    DirectorySaveDataFileSystem::DirectorySaveDataFileSystem(std::unique_ptr<fs::fsa::IFileSystem> fs)
+        : PathResolutionFileSystem(std::move(fs)), open_writable_files(0)
+    {
+        /* ... */
+    }
+
+    DirectorySaveDataFileSystem::~DirectorySaveDataFileSystem() {
+        /* ... */
+    }
+
+    Result DirectorySaveDataFileSystem::Initialize() {
+        /* Nintendo does not acquire the lock here, but I think we probably should. */
+        std::scoped_lock lk(this->accessor_mutex);
+
+        fs::DirectoryEntryType type;
+
+        /* Check that the working directory exists. */
+        R_TRY_CATCH(this->base_fs->GetEntryType(&type, WorkingDirectoryPath)) {
+            /* If path isn't found, create working directory and committed directory. */
+            R_CATCH(fs::ResultPathNotFound) {
+                R_TRY(this->base_fs->CreateDirectory(WorkingDirectoryPath));
+                R_TRY(this->base_fs->CreateDirectory(CommittedDirectoryPath));
+            }
+        } R_END_TRY_CATCH;
+
+        /* Now check for the committed directory. */
+        R_TRY_CATCH(this->base_fs->GetEntryType(&type, CommittedDirectoryPath)) {
+            /* Committed doesn't exist, so synchronize and rename. */
+            R_CATCH(fs::ResultPathNotFound) {
+                R_TRY(this->SynchronizeDirectory(SynchronizingDirectoryPath, WorkingDirectoryPath));
+                R_TRY(this->base_fs->RenameDirectory(SynchronizingDirectoryPath, CommittedDirectoryPath));
+                return ResultSuccess();
+            }
+        } R_END_TRY_CATCH;
+
+        /* The committed directory exists, so synchronize it to the working directory. */
+        return this->SynchronizeDirectory(WorkingDirectoryPath, CommittedDirectoryPath);
+    }
+
+    Result DirectorySaveDataFileSystem::AllocateWorkBuffer(std::unique_ptr<u8[]> *out, size_t *out_size, size_t size) {
+        /* Repeatedly try to allocate until success. */
+        while (size > 0x200) {
+            /* Allocate the buffer. */
+            if (auto mem = new (std::nothrow) u8[size]; mem != nullptr) {
+                out->reset(mem);
+                *out_size = size;
+                return ResultSuccess();
+            } else {
+                /* Divide size by two. */
+                size >>= 1;
+            }
+        }
+
+        /* TODO: Return a result here? Nintendo does not, but they have other allocation failed results. */
+        /* Consider returning ResultFsAllocationFailureInDirectorySaveDataFileSystem? */
+        AMS_ASSERT(false);
+    }
+
+    Result DirectorySaveDataFileSystem::SynchronizeDirectory(const char *dst, const char *src) {
+        /* Delete destination dir and recreate it. */
+        R_TRY_CATCH(this->base_fs->DeleteDirectoryRecursively(dst)) {
+            R_CATCH(fs::ResultPathNotFound) { /* Nintendo returns error unconditionally, but I think that's a bug in their code. */}
+        } R_END_TRY_CATCH;
+
+        R_TRY(this->base_fs->CreateDirectory(dst));
+
+        /* Get a work buffer to work with. */
+        std::unique_ptr<u8[]> work_buf;
+        size_t work_buf_size;
+        R_TRY(this->AllocateWorkBuffer(&work_buf, &work_buf_size, IdealWorkBufferSize));
+
+        /* Copy the directory recursively. */
+        return fssystem::CopyDirectoryRecursively(this->base_fs, dst, src, work_buf.get(), work_buf_size);
+    }
+
+    Result DirectorySaveDataFileSystem::ResolveFullPath(char *out, size_t out_size, const char *relative_path) {
+        R_UNLESS(strnlen(relative_path, fs::EntryNameLengthMax + 1) < fs::EntryNameLengthMax + 1, fs::ResultTooLongPath());
+        R_UNLESS(PathTool::IsSeparator(relative_path[0]), fs::ResultInvalidPath());
+
+        /* Copy working directory path. */
+        std::strncpy(out, WorkingDirectoryPath, out_size);
+        out[out_size - 1] = StringTraits::NullTerminator;
+
+        /* Normalize it. */
+        constexpr size_t WorkingDirectoryPathLength = sizeof(WorkingDirectoryPath) - 1;
+        size_t normalized_length;
+        return PathTool::Normalize(out + WorkingDirectoryPathLength - 1, &normalized_length, relative_path, out_size - (WorkingDirectoryPathLength - 1));
+    }
+
+    void DirectorySaveDataFileSystem::OnWritableFileClose() {
+        std::scoped_lock lk(this->accessor_mutex);
+        this->open_writable_files--;
+
+        /* Nintendo does not check this, but I think it's sensible to do so. */
+        AMS_ASSERT(this->open_writable_files >= 0);
+    }
+
+    Result DirectorySaveDataFileSystem::CopySaveFromFileSystem(fs::fsa::IFileSystem *save_fs) {
+        /* If the input save is null, there's nothing to copy. */
+        R_UNLESS(save_fs != nullptr, ResultSuccess());
+
+        /* Get a work buffer to work with. */
+        std::unique_ptr<u8[]> work_buf;
+        size_t work_buf_size;
+        R_TRY(this->AllocateWorkBuffer(&work_buf, &work_buf_size, IdealWorkBufferSize));
+
+        /* Copy the directory recursively. */
+        R_TRY(fssystem::CopyDirectoryRecursively(this->base_fs, save_fs, PathTool::RootPath, PathTool::RootPath, work_buf.get(), work_buf_size));
+
+        return this->Commit();
+    }
+
+    /* Overridden from IPathResolutionFileSystem */
+    Result DirectorySaveDataFileSystem::OpenFileImpl(std::unique_ptr<fs::fsa::IFile> *out_file, const char *path, fs::OpenMode mode) {
+        char full_path[fs::EntryNameLengthMax + 1];
+        R_TRY(this->ResolveFullPath(full_path, sizeof(full_path), path));
+
+        std::scoped_lock lk(this->accessor_mutex);
+        std::unique_ptr<fs::fsa::IFile> base_file;
+        R_TRY(this->base_fs->OpenFile(&base_file, full_path, mode));
+
+        std::unique_ptr<DirectorySaveDataFile> file(new (std::nothrow) DirectorySaveDataFile(std::move(base_file), this, mode));
+        R_UNLESS(file != nullptr, fs::ResultAllocationFailureInDirectorySaveDataFileSystem());
+
+        if (mode & fs::OpenMode_Write) {
+            this->open_writable_files++;
+        }
+
+        *out_file = std::move(file);
+        return ResultSuccess();
+    }
+
+    Result DirectorySaveDataFileSystem::CommitImpl() {
+        /* Here, Nintendo does the following (with retries): */
+        /* - Rename Committed -> Synchronizing. */
+        /* - Synchronize Working -> Synchronizing (deleting Synchronizing). */
+        /* - Rename Synchronizing -> Committed. */
+        std::scoped_lock lk(this->accessor_mutex);
+
+        R_UNLESS(this->open_writable_files == 0, fs::ResultPreconditionViolation());
+
+        const auto RenameCommitedDir      = [&]() { return this->base_fs->RenameDirectory(CommittedDirectoryPath, SynchronizingDirectoryPath); };
+        const auto SynchronizeWorkingDir  = [&]() { return this->SynchronizeDirectory(SynchronizingDirectoryPath, WorkingDirectoryPath); };
+        const auto RenameSynchronizingDir = [&]() { return this->base_fs->RenameDirectory(SynchronizingDirectoryPath, CommittedDirectoryPath); };
+
+        /* Rename Committed -> Synchronizing. */
+        R_TRY(fssystem::RetryFinitelyForTargetLocked(std::move(RenameCommitedDir)));
+
+        /* - Synchronize Working -> Synchronizing (deleting Synchronizing). */
+        R_TRY(fssystem::RetryFinitelyForTargetLocked(std::move(SynchronizeWorkingDir)));
+
+        /* - Rename Synchronizing -> Committed. */
+        R_TRY(fssystem::RetryFinitelyForTargetLocked(std::move(RenameSynchronizingDir)));
+
+        /* TODO: Should I call this->base_fs->Commit()? Nintendo does not. */
+        return ResultSuccess();
+    }
+
+    /* Overridden from IPathResolutionFileSystem but not commands. */
+    Result DirectorySaveDataFileSystem::CommitProvisionallyImpl(s64 counter) {
+        /* Nintendo does nothing here. */
+        return ResultSuccess();
+    }
+
+    Result DirectorySaveDataFileSystem::RollbackImpl() {
+        /* Initialize overwrites the working directory with the committed directory. */
+        return this->Initialize();
+    }
+
+    /* Explicitly overridden to be not implemented. */
+    Result DirectorySaveDataFileSystem::GetFreeSpaceSizeImpl(s64 *out, const char *path) {
+        return fs::ResultNotImplemented();
+    }
+
+    Result DirectorySaveDataFileSystem::GetTotalSpaceSizeImpl(s64 *out, const char *path) {
+        return fs::ResultNotImplemented();
+    }
+
+    Result DirectorySaveDataFileSystem::GetFileTimeStampRawImpl(fs::FileTimeStampRaw *out, const char *path) {
+        return fs::ResultNotImplemented();
+    }
+
+    Result DirectorySaveDataFileSystem::QueryEntryImpl(char *dst, size_t dst_size, const char *src, size_t src_size, fs::fsa::QueryId query, const char *path) {
+        return fs::ResultNotImplemented();
+    }
+
+    Result DirectorySaveDataFileSystem::FlushImpl() {
+        return fs::ResultNotImplemented();
+    }
+
+}

libraries/libstratosphere/source/fssystem/fssystem_subdirectory_filesystem.cpp

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2018-2019 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>
+
+namespace ams::fssystem {
+
+    SubDirectoryFileSystem::SubDirectoryFileSystem(std::shared_ptr<fs::fsa::IFileSystem> fs, const char *bp, bool unc)
+        : PathResolutionFileSystem(fs, unc)
+    {
+        this->base_path = nullptr;
+        R_ASSERT(this->Initialize(bp));
+    }
+
+    SubDirectoryFileSystem::SubDirectoryFileSystem(std::unique_ptr<fs::fsa::IFileSystem> fs, const char *bp, bool unc)
+        : PathResolutionFileSystem(std::move(fs), unc)
+    {
+        this->base_path = nullptr;
+        R_ASSERT(this->Initialize(bp));
+    }
+
+    SubDirectoryFileSystem::~SubDirectoryFileSystem() {
+        if (this->base_path != nullptr) {
+            std::free(this->base_path);
+        }
+    }
+
+    Result SubDirectoryFileSystem::Initialize(const char *bp) {
+        /* Make sure the path isn't too long. */
+        R_UNLESS(strnlen(bp, fs::EntryNameLengthMax + 1) <= fs::EntryNameLengthMax, fs::ResultTooLongPath());
+
+        /* Normalize the path. */
+        char normalized_path[fs::EntryNameLengthMax + 2];
+        size_t normalized_path_len;
+        R_TRY(PathTool::Normalize(normalized_path, &normalized_path_len, bp, sizeof(normalized_path), this->IsUncPreserved()));
+
+        /* Ensure terminating '/' */
+        if (!PathTool::IsSeparator(normalized_path[normalized_path_len - 1])) {
+            AMS_ASSERT(normalized_path_len + 2 <= sizeof(normalized_path));
+            normalized_path[normalized_path_len]     = StringTraits::DirectorySeparator;
+            normalized_path[normalized_path_len + 1] = StringTraits::NullTerminator;
+
+            normalized_path_len++;
+        }
+
+        /* Allocate new path. */
+        this->base_path_len = normalized_path_len + 1;
+        this->base_path = static_cast<char *>(std::malloc(this->base_path_len));
+        R_UNLESS(this->base_path != nullptr, fs::ResultAllocationFailureInSubDirectoryFileSystem());
+
+        /* Copy path in. */
+        std::memcpy(this->base_path, normalized_path, normalized_path_len);
+        this->base_path[normalized_path_len] = StringTraits::NullTerminator;
+        return ResultSuccess();
+    }
+
+    Result SubDirectoryFileSystem::ResolveFullPath(char *out, size_t out_size, const char *relative_path) {
+        /* Ensure path will fit. */
+        R_UNLESS(this->base_path_len + strnlen(relative_path, fs::EntryNameLengthMax + 1) <= out_size, fs::ResultTooLongPath());
+
+        /* Copy base path. */
+        std::memcpy(out, this->base_path, this->base_path_len);
+
+        /* Normalize it. */
+        const size_t prefix_size = this->base_path_len - 2;
+        size_t normalized_len;
+        return PathTool::Normalize(out + prefix_size, &normalized_len, relative_path, out_size - prefix_size, this->IsUncPreserved());
+    }
+
+}

libraries/libstratosphere/source/fssystem/fssystem_utility.cpp

@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2018-2019 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>
+
+namespace ams::fssystem {
+
+    namespace {
+
+        inline Result EnsureDirectoryExists(fs::fsa::IFileSystem *fs, const char *path) {
+            R_TRY_CATCH(fs->CreateDirectory(path)) {
+                R_CATCH(fs::ResultPathAlreadyExists) { /* If path already exists, there's no problem. */ }
+            } R_END_TRY_CATCH;
+
+            return ResultSuccess();
+        }
+
+    }
+
+    Result CopyFile(fs::fsa::IFileSystem *dst_fs, fs::fsa::IFileSystem *src_fs, const char *dst_parent_path, const char *src_path, const fs::DirectoryEntry *entry, void *work_buf, size_t work_buf_size) {
+        /* Open source file. */
+        std::unique_ptr<fs::fsa::IFile> src_file;
+        R_TRY(src_fs->OpenFile(&src_file, src_path, fs::OpenMode_Read));
+
+        /* Open dst file. */
+        std::unique_ptr<fs::fsa::IFile> dst_file;
+        {
+            char dst_path[fs::EntryNameLengthMax + 1];
+            const size_t original_size = static_cast<size_t>(std::snprintf(dst_path, sizeof(dst_path), "%s%s", dst_parent_path, entry->name));
+            /* TODO: Error code? N aborts here. */
+            AMS_ASSERT(original_size < sizeof(dst_path));
+
+            R_TRY(dst_fs->CreateFile(dst_path, entry->file_size));
+            R_TRY(dst_fs->OpenFile(&dst_file, dst_path, fs::OpenMode_Write));
+        }
+
+        /* Read/Write file in work buffer sized chunks. */
+        s64 remaining = entry->file_size;
+        s64 offset = 0;
+        while (remaining > 0) {
+            size_t read_size;
+            R_TRY(src_file->Read(&read_size, offset, work_buf, work_buf_size, fs::ReadOption()));
+            R_TRY(dst_file->Write(offset, work_buf, read_size, fs::WriteOption()));
+
+            remaining -= read_size;
+            offset    += read_size;
+        }
+
+        return ResultSuccess();
+    }
+
+    Result CopyDirectoryRecursively(fs::fsa::IFileSystem *dst_fs, fs::fsa::IFileSystem *src_fs, const char *dst_path, const char *src_path, void *work_buf, size_t work_buf_size) {
+        char dst_path_buf[fs::EntryNameLengthMax + 1];
+        const size_t original_size = static_cast<size_t>(std::snprintf(dst_path_buf, sizeof(dst_path_buf), "%s", dst_path));
+        AMS_ASSERT(original_size < sizeof(dst_path_buf));
+
+        return IterateDirectoryRecursively(src_fs, src_path,
+            [&](const char *path, const fs::DirectoryEntry &entry) -> Result { /* On Enter Directory */
+                /* Update path, create new dir. */
+                std::strncat(dst_path_buf, entry.name, sizeof(dst_path_buf) - strnlen(dst_path_buf, sizeof(dst_path_buf) - 1) - 1);
+                std::strncat(dst_path_buf, "/",        sizeof(dst_path_buf) - strnlen(dst_path_buf, sizeof(dst_path_buf) - 1) - 1);
+                return dst_fs->CreateDirectory(dst_path_buf);
+            },
+            [&](const char *path, const fs::DirectoryEntry &entry) -> Result { /* On Exit Directory */
+                /* Check we have a parent directory. */
+                const size_t len = strnlen(dst_path_buf, sizeof(dst_path_buf));
+                R_UNLESS(len >= 2, fs::ResultInvalidPathFormat());
+
+                /* Find previous separator, add null terminator */
+                char *cur = &dst_path_buf[len - 2];
+                while (!PathTool::IsSeparator(*cur) && cur > dst_path_buf) {
+                    cur--;
+                }
+                cur[1] = StringTraits::NullTerminator;
+
+                return ResultSuccess();
+            },
+            [&](const char *path, const fs::DirectoryEntry &entry) -> Result { /* On File */
+                return CopyFile(dst_fs, src_fs, dst_path_buf, path, &entry, work_buf, work_buf_size);
+            }
+        );
+    }
+
+    Result EnsureDirectoryExistsRecursively(fs::fsa::IFileSystem *fs, const char *path) {
+        /* Normalize the path. */
+        char normalized_path[fs::EntryNameLengthMax + 1];
+        size_t normalized_path_len;
+        R_TRY(PathTool::Normalize(normalized_path, &normalized_path_len, path, sizeof(normalized_path)));
+
+        /* Repeatedly call CreateDirectory on each directory leading to the target. */
+        for (size_t i = 1; i < normalized_path_len; i++) {
+            /* If we detect a separator, create the directory. */
+            if (PathTool::IsSeparator(normalized_path[i])) {
+                normalized_path[i] = StringTraits::NullTerminator;
+                R_TRY(EnsureDirectoryExists(fs, normalized_path));
+                normalized_path[i] = StringTraits::DirectorySeparator;
+            }
+        }
+
+        /* Call CreateDirectory on the final path. */
+        R_TRY(EnsureDirectoryExists(fs, normalized_path));
+
+        return ResultSuccess();
+    }
+
+}