mika/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere.git synced 2025-07-04 16:42:14 +02:00
Code Issues Packages Projects Releases Wiki Activity

fs.mitm: Use variant

Browse Source
This commit is contained in:
Tony Wasserka 2018-06-16 16:42:21 +02:00
parent f65983c5a7
commit e71758a1f3
4 changed files with 111 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
stratosphere/fs_mitm/source/fsmitm_layeredrom.cpp
View File

@ -27,10 +27,6 @@ LayeredRomFS::LayeredRomFS(std::shared_ptr<RomInterfaceStorage> s_r, std::shared
build_ctx.Build(this->p_source_infos.get()); build_ctx.Build(this->p_source_infos.get());
} }
LayeredRomFS::~LayeredRomFS() {
/* ... */
}
Result LayeredRomFS::Read(void *buffer, size_t size, u64 offset) { Result LayeredRomFS::Read(void *buffer, size_t size, u64 offset) {
/* Validate size. */ /* Validate size. */
@ -60,7 +56,6 @@ Result LayeredRomFS::Read(void *buffer, size_t size, u64 offset) {
} }
} }
Result rc;
size_t read_so_far = 0; size_t read_so_far = 0;
while (read_so_far < size) { while (read_so_far < size) {
RomFSSourceInfo *cur_source = &((*this->p_source_infos)[cur_source_ind]); RomFSSourceInfo *cur_source = &((*this->p_source_infos)[cur_source_ind]);
@ -69,11 +64,11 @@ Result LayeredRomFS::Read(void *buffer, size_t size, u64 offset) {
if (cur_read_size > cur_source->size - (offset - cur_source->virtual_offset)) { if (cur_read_size > cur_source->size - (offset - cur_source->virtual_offset)) {
cur_read_size = cur_source->size - (offset - cur_source->virtual_offset); cur_read_size = cur_source->size - (offset - cur_source->virtual_offset);
} }
switch (cur_source->type) { auto source_info_visitor = [&](auto& info) -> Result {
case RomFSDataSource_LooseFile: Result rc = 0;
{ if constexpr (std::is_same_v<decltype(info), RomFSBaseSourceInfo>) {
FsFile file; FsFile file;
if (R_FAILED((rc = Utils::OpenRomFSSdFile(this->title_id, cur_source->loose_source_info.path, FS_OPEN_READ, &file)))) { if (R_FAILED((rc = Utils::OpenRomFSSdFile(this->title_id, info.path, FS_OPEN_READ, &file)))) {
fatalSimple(rc); fatalSimple(rc);
} }
size_t out_read; size_t out_read;
@ -84,32 +79,23 @@ Result LayeredRomFS::Read(void *buffer, size_t size, u64 offset) {
Reboot(); Reboot();
} }
fsFileClose(&file); fsFileClose(&file);
} } else if constexpr (std::is_same_v<decltype(info), RomFSFileSourceInfo>) {
break; memcpy((void *)((uintptr_t)buffer + read_so_far), info.data + (offset - cur_source->virtual_offset), cur_read_size);
case RomFSDataSource_Memory: } else if constexpr (std::is_same_v<decltype(info), RomFSLooseSourceInfo>) {
{ if (R_FAILED((rc = this->storage_romfs->Read((void *)((uintptr_t)buffer + read_so_far), cur_read_size, info.offset + (offset - cur_source->virtual_offset))))) {
memcpy((void *)((uintptr_t)buffer + read_so_far), cur_source->memory_source_info.data + (offset - cur_source->virtual_offset), cur_read_size);
}
break;
case RomFSDataSource_BaseRomFS:
{
if (R_FAILED((rc = this->storage_romfs->Read((void *)((uintptr_t)buffer + read_so_far), cur_read_size, cur_source->base_source_info.offset + (offset - cur_source->virtual_offset))))) {
/* TODO: Can this ever happen? */ /* TODO: Can this ever happen? */
/* fatalSimple(rc); */ /* fatalSimple(rc); */
return rc; return rc;
} }
} } else if constexpr (std::is_same_v<decltype(info), RomFSMemorySourceInfo>) {
break; if (R_FAILED((rc = this->file_romfs->Read((void *)((uintptr_t)buffer + read_so_far), cur_read_size, info.offset + (offset - cur_source->virtual_offset))))) {
case RomFSDataSource_FileRomFS:
{
if (R_FAILED((rc = this->file_romfs->Read((void *)((uintptr_t)buffer + read_so_far), cur_read_size, cur_source->base_source_info.offset + (offset - cur_source->virtual_offset))))) {
fatalSimple(rc); fatalSimple(rc);
} }
} }
break; return rc;
default: };
fatalSimple(0xF601); Result rc = std::visit(source_info_visitor, cur_source->info);
}
read_so_far += cur_read_size; read_so_far += cur_read_size;
} else { } else {
/* Handle padding explicitly. */ /* Handle padding explicitly. */

2
stratosphere/fs_mitm/source/fsmitm_layeredrom.hpp
View File

@ -23,7 +23,7 @@ class LayeredRomFS : public IROStorage {
public: public:
LayeredRomFS(std::shared_ptr<RomInterfaceStorage> s_r, std::shared_ptr<RomFileStorage> f_r, u64 tid); LayeredRomFS(std::shared_ptr<RomInterfaceStorage> s_r, std::shared_ptr<RomFileStorage> f_r, u64 tid);
virtual ~LayeredRomFS(); virtual ~LayeredRomFS() = default;
Result Read(void *buffer, size_t size, u64 offset) override; Result Read(void *buffer, size_t size, u64 offset) override;
Result GetSize(u64 *out_size) override; Result GetSize(u64 *out_size) override;

2
stratosphere/fs_mitm/source/fsmitm_romfsbuild.cpp
View File

@ -359,7 +359,7 @@ void RomFSBuildContext::Build(std::vector<RomFSSourceInfo> *out_infos) {
case RomFSDataSource_BaseRomFS: case RomFSDataSource_BaseRomFS:
case RomFSDataSource_FileRomFS: case RomFSDataSource_FileRomFS:
/* Try to compact, if possible. */ /* Try to compact, if possible. */
if (out_infos->back().type == cur_file->source) { if (out_infos->back().GetType() == cur_file->source) {
out_infos->back().size = cur_file->offset + ROMFS_FILEPARTITION_OFS + cur_file->size - out_infos->back().virtual_offset; out_infos->back().size = cur_file->offset + ROMFS_FILEPARTITION_OFS + cur_file->size - out_infos->back().virtual_offset;
} else { } else {
out_infos->push_back(RomFSSourceInfo(cur_file->offset + ROMFS_FILEPARTITION_OFS, cur_file->size, cur_file->orig_offset + ROMFS_FILEPARTITION_OFS, cur_file->source)); out_infos->push_back(RomFSSourceInfo(cur_file->offset + ROMFS_FILEPARTITION_OFS, cur_file->size, cur_file->orig_offset + ROMFS_FILEPARTITION_OFS, cur_file->source));

121
stratosphere/fs_mitm/source/fsmitm_romfsbuild.hpp
View File

@ -1,5 +1,6 @@
#pragma once #pragma once
#include <switch.h> #include <switch.h>
#include <variant>
#include "fsmitm_romstorage.hpp" #include "fsmitm_romstorage.hpp"
@ -30,66 +31,92 @@ struct RomFSMemorySourceInfo {
const u8 *data; const u8 *data;
}; };
struct RomFSSourceInfo { class RomFSSourceInfo {
using InfoVariant = std::variant<RomFSBaseSourceInfo, RomFSFileSourceInfo, RomFSLooseSourceInfo, RomFSMemorySourceInfo>;
static InfoVariant MakeInfoVariantFromOffset(u64 offset, RomFSDataSource t) {
switch(t) {
case RomFSDataSource_BaseRomFS:
return RomFSBaseSourceInfo { offset };
case RomFSDataSource_FileRomFS:
return RomFSFileSourceInfo { offset };
default:
fatalSimple(0xF601);
}
}
static InfoVariant MakeInfoVariantFromPointer(const void *arg, RomFSDataSource t) {
switch(t) {
case RomFSDataSource_LooseFile:
return RomFSLooseSourceInfo { (decltype(RomFSLooseSourceInfo::path))arg };
case RomFSDataSource_Memory:
return RomFSMemorySourceInfo { (decltype(RomFSMemorySourceInfo::data))arg };
default:
fatalSimple(0xF601);
}
}
struct InfoCleanupHelper {
void operator()(RomFSBaseSourceInfo& info) {
}
void operator()(RomFSFileSourceInfo& info) {
}
void operator()(RomFSLooseSourceInfo& info) {
delete info.path;
}
void operator()(RomFSMemorySourceInfo& info) {
delete info.data;
}
};
struct GetTypeHelper {
RomFSDataSource operator()(const RomFSBaseSourceInfo& info) const {
return RomFSDataSource_BaseRomFS;
}
RomFSDataSource operator()(const RomFSFileSourceInfo& info) const {
return RomFSDataSource_FileRomFS;
}
RomFSDataSource operator()(const RomFSLooseSourceInfo& info) const {
return RomFSDataSource_LooseFile;
}
RomFSDataSource operator()(const RomFSMemorySourceInfo& info) const {
return RomFSDataSource_Memory;
}
};
public:
u64 virtual_offset; u64 virtual_offset;
u64 size; u64 size;
union {
RomFSBaseSourceInfo base_source_info;
RomFSFileSourceInfo file_source_info;
RomFSLooseSourceInfo loose_source_info;
RomFSMemorySourceInfo memory_source_info;
};
RomFSDataSource type;
RomFSSourceInfo(u64 v_o, u64 s, u64 offset, RomFSDataSource t) : virtual_offset(v_o), size(s), type(t) { InfoVariant info;
switch (this->type) {
case RomFSDataSource_BaseRomFS: RomFSSourceInfo(u64 v_o, u64 s, u64 offset, RomFSDataSource t) : virtual_offset(v_o), size(s), info(MakeInfoVariantFromOffset(offset, t)) {
this->base_source_info.offset = offset;
break;
case RomFSDataSource_FileRomFS:
this->file_source_info.offset = offset;
break;
case RomFSDataSource_LooseFile:
case RomFSDataSource_Memory:
default:
fatalSimple(0xF601);
}
} }
RomFSSourceInfo(u64 v_o, u64 s, const void *arg, RomFSDataSource t) : virtual_offset(v_o), size(s), type(t) { RomFSSourceInfo(u64 v_o, u64 s, const void *arg, RomFSDataSource t) : virtual_offset(v_o), size(s), info(MakeInfoVariantFromPointer(arg, t)) {
switch (this->type) {
case RomFSDataSource_LooseFile:
this->loose_source_info.path = (decltype(this->loose_source_info.path))arg;
break;
case RomFSDataSource_Memory:
this->memory_source_info.data = (decltype(this->memory_source_info.data))arg;
break;
case RomFSDataSource_BaseRomFS:
case RomFSDataSource_FileRomFS:
default:
fatalSimple(0xF601);
}
} }
void Cleanup() { void Cleanup() {
switch (this->type) { std::visit(InfoCleanupHelper{}, info);
case RomFSDataSource_BaseRomFS:
case RomFSDataSource_FileRomFS:
break;
case RomFSDataSource_LooseFile:
delete this->loose_source_info.path;
break;
case RomFSDataSource_Memory:
delete this->memory_source_info.data;
break;
default:
fatalSimple(0xF601);
}
} }
static bool Compare(RomFSSourceInfo *a, RomFSSourceInfo *b) { static bool Compare(RomFSSourceInfo *a, RomFSSourceInfo *b) {
return (a->virtual_offset < b->virtual_offset); return (a->virtual_offset < b->virtual_offset);
} }
RomFSDataSource GetType() const {
return std::visit(GetTypeHelper{}, info);
}
}; };
/* Types for building a RomFS. */ /* Types for building a RomFS. */