summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/core/file_sys/fsmitm_romfsbuild.cpp368
-rw-r--r--src/core/file_sys/fsmitm_romfsbuild.hpp106
2 files changed, 474 insertions, 0 deletions
diff --git a/src/core/file_sys/fsmitm_romfsbuild.cpp b/src/core/file_sys/fsmitm_romfsbuild.cpp
new file mode 100644
index 000000000..a6fe6719d
--- /dev/null
+++ b/src/core/file_sys/fsmitm_romfsbuild.cpp
@@ -0,0 +1,368 @@
+/*
+ * Copyright (c) 2018 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/>.
+ */
+
+/*
+ * Adapted by DarkLordZach for use/interaction with yuzu
+ *
+ * Modifications Copyright 2018 yuzu emulator team
+ * Licensed under GPLv2 or any later version
+ * Refer to the license.txt file included.
+ */
+
+#include <cstring>
+#include "common/assert.h"
+#include "fsmitm_romfsbuild.hpp"
+#include "vfs.h"
+#include "vfs_vector.h"
+
+namespace FileSys {
+
+constexpr u64 FS_MAX_PATH = 0x301;
+
+constexpr u32 ROMFS_ENTRY_EMPTY = 0xFFFFFFFF;
+constexpr u32 ROMFS_FILEPARTITION_OFS = 0x200;
+
+/* Types for building a RomFS. */
+struct RomFSHeader {
+ u64 header_size;
+ u64 dir_hash_table_ofs;
+ u64 dir_hash_table_size;
+ u64 dir_table_ofs;
+ u64 dir_table_size;
+ u64 file_hash_table_ofs;
+ u64 file_hash_table_size;
+ u64 file_table_ofs;
+ u64 file_table_size;
+ u64 file_partition_ofs;
+};
+static_assert(sizeof(RomFSHeader) == 0x50, "RomFSHeader has incorrect size.");
+
+struct RomFSDirectoryEntry {
+ u32 parent;
+ u32 sibling;
+ u32 child;
+ u32 file;
+ u32 hash;
+ u32 name_size;
+ char name[];
+};
+static_assert(sizeof(RomFSDirectoryEntry) == 0x18, "RomFSDirectoryEntry has incorrect size.");
+
+struct RomFSFileEntry {
+ u32 parent;
+ u32 sibling;
+ u64 offset;
+ u64 size;
+ u32 hash;
+ u32 name_size;
+ char name[];
+};
+static_assert(sizeof(RomFSFileEntry) == 0x20, "RomFSFileEntry has incorrect size.");
+
+struct RomFSBuildFileContext;
+
+struct RomFSBuildDirectoryContext {
+ char* path;
+ u32 cur_path_ofs;
+ u32 path_len;
+ u32 entry_offset = 0;
+ RomFSBuildDirectoryContext* parent = nullptr;
+ RomFSBuildDirectoryContext* child = nullptr;
+ RomFSBuildDirectoryContext* sibling = nullptr;
+ RomFSBuildFileContext* file = nullptr;
+};
+
+struct RomFSBuildFileContext {
+ char* path;
+ u32 cur_path_ofs;
+ u32 path_len;
+ u32 entry_offset = 0;
+ u64 offset = 0;
+ u64 size = 0;
+ RomFSBuildDirectoryContext* parent = nullptr;
+ RomFSBuildFileContext* sibling = nullptr;
+ VirtualFile source = nullptr;
+};
+
+void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs, RomFSBuildDirectoryContext* parent) {
+ std::vector<RomFSBuildDirectoryContext*> child_dirs;
+
+ VirtualDir dir;
+
+ if (parent->path_len == 0)
+ dir = root_romfs;
+ else
+ dir = root_romfs->GetDirectoryRelative(parent->path);
+
+ const auto entries = dir->GetEntries();
+
+ for (const auto& kv : entries) {
+ if (kv.second == VfsEntryType::Directory) {
+ RomFSBuildDirectoryContext* child = new RomFSBuildDirectoryContext({0});
+ /* Set child's path. */
+ child->cur_path_ofs = parent->path_len + 1;
+ child->path_len = child->cur_path_ofs + kv.first.size();
+ child->path = new char[child->path_len + 1];
+ strcpy(child->path, parent->path);
+ ASSERT(child->path_len < FS_MAX_PATH);
+ strcat(child->path + parent->path_len, "/");
+ strcat(child->path + parent->path_len, kv.first.c_str());
+
+ if (!this->AddDirectory(parent, child, nullptr)) {
+ delete child->path;
+ delete child;
+ } else {
+ child_dirs.push_back(child);
+ }
+ } else {
+ RomFSBuildFileContext* child = new RomFSBuildFileContext({0});
+ /* Set child's path. */
+ child->cur_path_ofs = parent->path_len + 1;
+ child->path_len = child->cur_path_ofs + kv.first.size();
+ child->path = new char[child->path_len + 1];
+ strcpy(child->path, parent->path);
+ ASSERT(child->path_len < FS_MAX_PATH);
+ strcat(child->path + parent->path_len, "/");
+ strcat(child->path + parent->path_len, kv.first.c_str());
+
+ child->source = root_romfs->GetFileRelative(child->path);
+
+ child->size = child->source->GetSize();
+
+ if (!this->AddFile(parent, child)) {
+ delete child->path;
+ delete child;
+ }
+ }
+ }
+
+ for (auto& child : child_dirs) {
+ this->VisitDirectory(root_romfs, child);
+ }
+}
+
+bool RomFSBuildContext::AddDirectory(RomFSBuildDirectoryContext* parent_dir_ctx,
+ RomFSBuildDirectoryContext* dir_ctx,
+ RomFSBuildDirectoryContext** out_dir_ctx) {
+ /* Check whether it's already in the known directories. */
+ auto existing = this->directories.find(dir_ctx->path);
+ if (existing != this->directories.end()) {
+ if (out_dir_ctx) {
+ *out_dir_ctx = existing->second;
+ }
+ return false;
+ }
+
+ /* Add a new directory. */
+ this->num_dirs++;
+ this->dir_table_size +=
+ sizeof(RomFSDirectoryEntry) + ((dir_ctx->path_len - dir_ctx->cur_path_ofs + 3) & ~3);
+ dir_ctx->parent = parent_dir_ctx;
+ this->directories.insert({dir_ctx->path, dir_ctx});
+
+ if (out_dir_ctx) {
+ *out_dir_ctx = dir_ctx;
+ }
+ return true;
+}
+
+bool RomFSBuildContext::AddFile(RomFSBuildDirectoryContext* parent_dir_ctx,
+ RomFSBuildFileContext* file_ctx) {
+ /* Check whether it's already in the known files. */
+ auto existing = this->files.find(file_ctx->path);
+ if (existing != this->files.end()) {
+ return false;
+ }
+
+ /* Add a new file. */
+ this->num_files++;
+ this->file_table_size +=
+ sizeof(RomFSFileEntry) + ((file_ctx->path_len - file_ctx->cur_path_ofs + 3) & ~3);
+ file_ctx->parent = parent_dir_ctx;
+ this->files.insert({file_ctx->path, file_ctx});
+
+ return true;
+}
+
+RomFSBuildContext::RomFSBuildContext(VirtualDir base_) : base(std::move(base_)) {
+ this->root = new RomFSBuildDirectoryContext({0});
+ this->root->path = new char[1];
+ this->root->path[0] = '\x00';
+ this->directories.insert({this->root->path, this->root});
+ this->num_dirs = 1;
+ this->dir_table_size = 0x18;
+
+ VisitDirectory(base, this->root);
+}
+
+std::map<u64, VirtualFile> RomFSBuildContext::Build() {
+ std::map<u64, VirtualFile> out;
+ RomFSBuildFileContext* cur_file;
+ RomFSBuildDirectoryContext* cur_dir;
+
+ const auto dir_hash_table_entry_count = romfs_get_hash_table_count(this->num_dirs);
+ const auto file_hash_table_entry_count = romfs_get_hash_table_count(this->num_files);
+ this->dir_hash_table_size = 4 * dir_hash_table_entry_count;
+ this->file_hash_table_size = 4 * file_hash_table_entry_count;
+
+ /* Assign metadata pointers */
+ RomFSHeader* header = new RomFSHeader({0});
+ auto metadata = new u8[this->dir_hash_table_size + this->dir_table_size +
+ this->file_hash_table_size + this->file_table_size];
+ auto dir_hash_table = reinterpret_cast<u32*>(metadata);
+ const auto dir_table = reinterpret_cast<RomFSDirectoryEntry*>(
+ reinterpret_cast<uintptr_t>(dir_hash_table) + this->dir_hash_table_size);
+ auto file_hash_table =
+ reinterpret_cast<u32*>(reinterpret_cast<uintptr_t>(dir_table) + this->dir_table_size);
+ const auto file_table = reinterpret_cast<RomFSFileEntry*>(
+ reinterpret_cast<uintptr_t>(file_hash_table) + this->file_hash_table_size);
+
+ /* Clear out hash tables. */
+ for (u32 i = 0; i < dir_hash_table_entry_count; i++)
+ dir_hash_table[i] = ROMFS_ENTRY_EMPTY;
+ for (u32 i = 0; i < file_hash_table_entry_count; i++)
+ file_hash_table[i] = ROMFS_ENTRY_EMPTY;
+
+ out.clear();
+
+ /* Determine file offsets. */
+ u32 entry_offset = 0;
+ RomFSBuildFileContext* prev_file = nullptr;
+ for (const auto& it : this->files) {
+ cur_file = it.second;
+ this->file_partition_size = (this->file_partition_size + 0xFULL) & ~0xFULL;
+ cur_file->offset = this->file_partition_size;
+ this->file_partition_size += cur_file->size;
+ cur_file->entry_offset = entry_offset;
+ entry_offset +=
+ sizeof(RomFSFileEntry) + ((cur_file->path_len - cur_file->cur_path_ofs + 3) & ~3);
+ prev_file = cur_file;
+ }
+ /* Assign deferred parent/sibling ownership. */
+ for (auto it = this->files.rbegin(); it != this->files.rend(); it++) {
+ cur_file = it->second;
+ cur_file->sibling = cur_file->parent->file;
+ cur_file->parent->file = cur_file;
+ }
+
+ /* Determine directory offsets. */
+ entry_offset = 0;
+ for (const auto& it : this->directories) {
+ cur_dir = it.second;
+ cur_dir->entry_offset = entry_offset;
+ entry_offset +=
+ sizeof(RomFSDirectoryEntry) + ((cur_dir->path_len - cur_dir->cur_path_ofs + 3) & ~3);
+ }
+ /* Assign deferred parent/sibling ownership. */
+ for (auto it = this->directories.rbegin(); it->second != this->root; it++) {
+ cur_dir = it->second;
+ cur_dir->sibling = cur_dir->parent->child;
+ cur_dir->parent->child = cur_dir;
+ }
+
+ /* Populate file tables. */
+ for (const auto& it : this->files) {
+ cur_file = it.second;
+ RomFSFileEntry* cur_entry = romfs_get_fentry(file_table, cur_file->entry_offset);
+
+ cur_entry->parent = cur_file->parent->entry_offset;
+ cur_entry->sibling =
+ (cur_file->sibling == nullptr) ? ROMFS_ENTRY_EMPTY : cur_file->sibling->entry_offset;
+ cur_entry->offset = cur_file->offset;
+ cur_entry->size = cur_file->size;
+
+ const auto name_size = cur_file->path_len - cur_file->cur_path_ofs;
+ const auto hash = romfs_calc_path_hash(cur_file->parent->entry_offset,
+ reinterpret_cast<unsigned char*>(cur_file->path) +
+ cur_file->cur_path_ofs,
+ 0, name_size);
+ cur_entry->hash = file_hash_table[hash % file_hash_table_entry_count];
+ file_hash_table[hash % file_hash_table_entry_count] = cur_file->entry_offset;
+
+ cur_entry->name_size = name_size;
+ memset(cur_entry->name, 0, (cur_entry->name_size + 3) & ~3);
+ memcpy(cur_entry->name, cur_file->path + cur_file->cur_path_ofs, name_size);
+
+ out.emplace(cur_file->offset + ROMFS_FILEPARTITION_OFS, cur_file->source);
+ }
+
+ /* Populate dir tables. */
+ for (const auto& it : this->directories) {
+ cur_dir = it.second;
+ RomFSDirectoryEntry* cur_entry = romfs_get_direntry(dir_table, cur_dir->entry_offset);
+ cur_entry->parent = cur_dir == this->root ? 0 : cur_dir->parent->entry_offset;
+ cur_entry->sibling =
+ (cur_dir->sibling == nullptr) ? ROMFS_ENTRY_EMPTY : cur_dir->sibling->entry_offset;
+ cur_entry->child =
+ (cur_dir->child == nullptr) ? ROMFS_ENTRY_EMPTY : cur_dir->child->entry_offset;
+ cur_entry->file =
+ (cur_dir->file == nullptr) ? ROMFS_ENTRY_EMPTY : cur_dir->file->entry_offset;
+
+ u32 name_size = cur_dir->path_len - cur_dir->cur_path_ofs;
+ u32 hash = romfs_calc_path_hash(
+ cur_dir == this->root ? 0 : cur_dir->parent->entry_offset,
+ reinterpret_cast<unsigned char*>(cur_dir->path) + cur_dir->cur_path_ofs, 0, name_size);
+ cur_entry->hash = dir_hash_table[hash % dir_hash_table_entry_count];
+ dir_hash_table[hash % dir_hash_table_entry_count] = cur_dir->entry_offset;
+
+ cur_entry->name_size = name_size;
+ memset(cur_entry->name, 0, (cur_entry->name_size + 3) & ~3);
+ memcpy(cur_entry->name, cur_dir->path + cur_dir->cur_path_ofs, name_size);
+ }
+
+ /* Delete directories. */
+ for (const auto& it : this->directories) {
+ cur_dir = it.second;
+ delete cur_dir->path;
+ delete cur_dir;
+ }
+ this->root = nullptr;
+ this->directories.clear();
+
+ /* Delete files. */
+ for (const auto& it : this->files) {
+ cur_file = it.second;
+ delete cur_file->path;
+ delete cur_file;
+ }
+ this->files.clear();
+
+ /* Set header fields. */
+ header->header_size = sizeof(*header);
+ header->file_hash_table_size = this->file_hash_table_size;
+ header->file_table_size = this->file_table_size;
+ header->dir_hash_table_size = this->dir_hash_table_size;
+ header->dir_table_size = this->dir_table_size;
+ header->file_partition_ofs = ROMFS_FILEPARTITION_OFS;
+ header->dir_hash_table_ofs =
+ (header->file_partition_ofs + this->file_partition_size + 3ULL) & ~3ULL;
+ header->dir_table_ofs = header->dir_hash_table_ofs + header->dir_hash_table_size;
+ header->file_hash_table_ofs = header->dir_table_ofs + header->dir_table_size;
+ header->file_table_ofs = header->file_hash_table_ofs + header->file_hash_table_size;
+
+ std::vector<u8> header_data(sizeof(RomFSHeader));
+ std::memcpy(header_data.data(), header, header_data.size());
+ out.emplace(0, std::make_shared<VectorVfsFile>(header_data));
+
+ std::vector<u8> meta_out(this->file_hash_table_size + this->file_table_size +
+ this->dir_hash_table_size + this->dir_table_size);
+ std::memcpy(meta_out.data(), metadata, meta_out.size());
+ out.emplace(header->dir_hash_table_ofs, std::make_shared<VectorVfsFile>(meta_out));
+
+ return out;
+}
+
+} // namespace FileSys
diff --git a/src/core/file_sys/fsmitm_romfsbuild.hpp b/src/core/file_sys/fsmitm_romfsbuild.hpp
new file mode 100644
index 000000000..b897aab21
--- /dev/null
+++ b/src/core/file_sys/fsmitm_romfsbuild.hpp
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2018 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/>.
+ */
+
+/*
+ * Adapted by DarkLordZach for use/interaction with yuzu
+ *
+ * Modifications Copyright 2018 yuzu emulator team
+ * Licensed under GPLv2 or any later version
+ * Refer to the license.txt file included.
+ */
+
+#pragma once
+#include <map>
+#include <boost/detail/container_fwd.hpp>
+#include "common/common_types.h"
+#include "vfs.h"
+
+namespace FileSys {
+
+/* Used as comparator for std::map<char *, RomFSBuild*Context> */
+struct build_ctx_cmp {
+ bool operator()(const char* a, const char* b) const {
+ return strcmp(a, b) < 0;
+ }
+};
+
+struct RomFSDirectoryEntry;
+struct RomFSFileEntry;
+struct RomFSBuildDirectoryContext;
+struct RomFSBuildFileContext;
+
+class RomFSBuildContext {
+private:
+ VirtualDir base;
+ RomFSBuildDirectoryContext* root;
+ std::map<char*, RomFSBuildDirectoryContext*, build_ctx_cmp> directories;
+ std::map<char*, RomFSBuildFileContext*, build_ctx_cmp> files;
+ u64 num_dirs = 0;
+ u64 num_files = 0;
+ u64 dir_table_size = 0;
+ u64 file_table_size = 0;
+ u64 dir_hash_table_size = 0;
+ u64 file_hash_table_size = 0;
+ u64 file_partition_size = 0;
+
+ void VisitDirectory(VirtualDir filesys, RomFSBuildDirectoryContext* parent);
+
+ bool AddDirectory(RomFSBuildDirectoryContext* parent_dir_ctx,
+ RomFSBuildDirectoryContext* dir_ctx,
+ RomFSBuildDirectoryContext** out_dir_ctx);
+ bool AddFile(RomFSBuildDirectoryContext* parent_dir_ctx, RomFSBuildFileContext* file_ctx);
+
+public:
+ explicit RomFSBuildContext(VirtualDir base);
+
+ /* This finalizes the context. */
+ std::map<u64, VirtualFile> Build();
+};
+
+static inline RomFSDirectoryEntry* romfs_get_direntry(void* directories, uint32_t offset) {
+ return (RomFSDirectoryEntry*)((uintptr_t)directories + offset);
+}
+
+static inline RomFSFileEntry* romfs_get_fentry(void* files, uint32_t offset) {
+ return (RomFSFileEntry*)((uintptr_t)files + offset);
+}
+
+static inline uint32_t romfs_calc_path_hash(uint32_t parent, const unsigned char* path,
+ uint32_t start, size_t path_len) {
+ uint32_t hash = parent ^ 123456789;
+ for (uint32_t i = 0; i < path_len; i++) {
+ hash = (hash >> 5) | (hash << 27);
+ hash ^= path[start + i];
+ }
+
+ return hash;
+}
+
+static inline uint32_t romfs_get_hash_table_count(uint32_t num_entries) {
+ if (num_entries < 3) {
+ return 3;
+ } else if (num_entries < 19) {
+ return num_entries | 1;
+ }
+ uint32_t count = num_entries;
+ while (count % 2 == 0 || count % 3 == 0 || count % 5 == 0 || count % 7 == 0 ||
+ count % 11 == 0 || count % 13 == 0 || count % 17 == 0) {
+ count++;
+ }
+ return count;
+}
+
+} // namespace FileSys
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 13:06:54 +0100