file_sys: Port Atmosphere-NX fs_mitm implementation
This commit is contained in:
Zach Hilman
parent
940a711caf
commit
6eada3c57d
|
|
@ -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
|
||||
|
|
@ -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
|
||||
Reference in New Issue