39c8d18feb
Makes our error coverage a little more consistent across the board by applying it to Linux side of things as well. This also makes it more consistent with the warning settings in other libraries in the project. This also updates httplib to 0.7.9, as there are several warning cleanups made that allow us to enable several warnings as errors.
194 lines
7.1 KiB
C++
194 lines
7.1 KiB
C++
// Copyright 2018 yuzu emulator team
|
|
// Licensed under GPLv2 or any later version
|
|
// Refer to the license.txt file included.
|
|
|
|
#include <cinttypes>
|
|
#include <cstring>
|
|
#include <vector>
|
|
|
|
#include "common/common_funcs.h"
|
|
#include "common/file_util.h"
|
|
#include "common/hex_util.h"
|
|
#include "common/logging/log.h"
|
|
#include "common/lz4_compression.h"
|
|
#include "common/swap.h"
|
|
#include "core/core.h"
|
|
#include "core/file_sys/patch_manager.h"
|
|
#include "core/gdbstub/gdbstub.h"
|
|
#include "core/hle/kernel/code_set.h"
|
|
#include "core/hle/kernel/memory/page_table.h"
|
|
#include "core/hle/kernel/process.h"
|
|
#include "core/loader/nso.h"
|
|
#include "core/memory.h"
|
|
#include "core/settings.h"
|
|
|
|
namespace Loader {
|
|
namespace {
|
|
struct MODHeader {
|
|
u32_le magic;
|
|
u32_le dynamic_offset;
|
|
u32_le bss_start_offset;
|
|
u32_le bss_end_offset;
|
|
u32_le eh_frame_hdr_start_offset;
|
|
u32_le eh_frame_hdr_end_offset;
|
|
u32_le module_offset; // Offset to runtime-generated module object. typically equal to .bss base
|
|
};
|
|
static_assert(sizeof(MODHeader) == 0x1c, "MODHeader has incorrect size.");
|
|
|
|
std::vector<u8> DecompressSegment(const std::vector<u8>& compressed_data,
|
|
const NSOSegmentHeader& header) {
|
|
std::vector<u8> uncompressed_data =
|
|
Common::Compression::DecompressDataLZ4(compressed_data, header.size);
|
|
|
|
ASSERT_MSG(uncompressed_data.size() == header.size, "{} != {}", header.size,
|
|
uncompressed_data.size());
|
|
|
|
return uncompressed_data;
|
|
}
|
|
|
|
constexpr u32 PageAlignSize(u32 size) {
|
|
return static_cast<u32>((size + Core::Memory::PAGE_MASK) & ~Core::Memory::PAGE_MASK);
|
|
}
|
|
} // Anonymous namespace
|
|
|
|
bool NSOHeader::IsSegmentCompressed(size_t segment_num) const {
|
|
ASSERT_MSG(segment_num < 3, "Invalid segment {}", segment_num);
|
|
return ((flags >> segment_num) & 1) != 0;
|
|
}
|
|
|
|
AppLoader_NSO::AppLoader_NSO(FileSys::VirtualFile file) : AppLoader(std::move(file)) {}
|
|
|
|
FileType AppLoader_NSO::IdentifyType(const FileSys::VirtualFile& file) {
|
|
u32 magic = 0;
|
|
if (file->ReadObject(&magic) != sizeof(magic)) {
|
|
return FileType::Error;
|
|
}
|
|
|
|
if (Common::MakeMagic('N', 'S', 'O', '0') != magic) {
|
|
return FileType::Error;
|
|
}
|
|
|
|
return FileType::NSO;
|
|
}
|
|
|
|
std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::Process& process, Core::System& system,
|
|
const FileSys::VfsFile& file, VAddr load_base,
|
|
bool should_pass_arguments, bool load_into_process,
|
|
std::optional<FileSys::PatchManager> pm) {
|
|
if (file.GetSize() < sizeof(NSOHeader)) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
NSOHeader nso_header{};
|
|
if (sizeof(NSOHeader) != file.ReadObject(&nso_header)) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
if (nso_header.magic != Common::MakeMagic('N', 'S', 'O', '0')) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
// Build program image
|
|
Kernel::CodeSet codeset;
|
|
Kernel::PhysicalMemory program_image;
|
|
for (std::size_t i = 0; i < nso_header.segments.size(); ++i) {
|
|
std::vector<u8> data =
|
|
file.ReadBytes(nso_header.segments_compressed_size[i], nso_header.segments[i].offset);
|
|
if (nso_header.IsSegmentCompressed(i)) {
|
|
data = DecompressSegment(data, nso_header.segments[i]);
|
|
}
|
|
program_image.resize(nso_header.segments[i].location + static_cast<u32>(data.size()));
|
|
std::memcpy(program_image.data() + nso_header.segments[i].location, data.data(),
|
|
data.size());
|
|
codeset.segments[i].addr = nso_header.segments[i].location;
|
|
codeset.segments[i].offset = nso_header.segments[i].location;
|
|
codeset.segments[i].size = nso_header.segments[i].size;
|
|
}
|
|
|
|
if (should_pass_arguments && !Settings::values.program_args.empty()) {
|
|
const auto arg_data{Settings::values.program_args};
|
|
|
|
codeset.DataSegment().size += NSO_ARGUMENT_DATA_ALLOCATION_SIZE;
|
|
NSOArgumentHeader args_header{
|
|
NSO_ARGUMENT_DATA_ALLOCATION_SIZE, static_cast<u32_le>(arg_data.size()), {}};
|
|
const auto end_offset = program_image.size();
|
|
program_image.resize(static_cast<u32>(program_image.size()) +
|
|
NSO_ARGUMENT_DATA_ALLOCATION_SIZE);
|
|
std::memcpy(program_image.data() + end_offset, &args_header, sizeof(NSOArgumentHeader));
|
|
std::memcpy(program_image.data() + end_offset + sizeof(NSOArgumentHeader), arg_data.data(),
|
|
arg_data.size());
|
|
}
|
|
|
|
codeset.DataSegment().size += nso_header.segments[2].bss_size;
|
|
const u32 image_size{
|
|
PageAlignSize(static_cast<u32>(program_image.size()) + nso_header.segments[2].bss_size)};
|
|
program_image.resize(image_size);
|
|
|
|
for (std::size_t i = 0; i < nso_header.segments.size(); ++i) {
|
|
codeset.segments[i].size = PageAlignSize(codeset.segments[i].size);
|
|
}
|
|
|
|
// Apply patches if necessary
|
|
if (pm && (pm->HasNSOPatch(nso_header.build_id) || Settings::values.dump_nso)) {
|
|
std::vector<u8> pi_header;
|
|
pi_header.insert(pi_header.begin(), reinterpret_cast<u8*>(&nso_header),
|
|
reinterpret_cast<u8*>(&nso_header) + sizeof(NSOHeader));
|
|
pi_header.insert(pi_header.begin() + sizeof(NSOHeader), program_image.data(),
|
|
program_image.data() + program_image.size());
|
|
|
|
pi_header = pm->PatchNSO(pi_header, file.GetName());
|
|
|
|
std::copy(pi_header.begin() + sizeof(NSOHeader), pi_header.end(), program_image.data());
|
|
}
|
|
|
|
// If we aren't actually loading (i.e. just computing the process code layout), we are done
|
|
if (!load_into_process) {
|
|
return load_base + image_size;
|
|
}
|
|
|
|
// Apply cheats if they exist and the program has a valid title ID
|
|
if (pm) {
|
|
system.SetCurrentProcessBuildID(nso_header.build_id);
|
|
const auto cheats = pm->CreateCheatList(system, nso_header.build_id);
|
|
if (!cheats.empty()) {
|
|
system.RegisterCheatList(cheats, nso_header.build_id, load_base, image_size);
|
|
}
|
|
}
|
|
|
|
// Load codeset for current process
|
|
codeset.memory = std::move(program_image);
|
|
process.LoadModule(std::move(codeset), load_base);
|
|
|
|
// Register module with GDBStub
|
|
GDBStub::RegisterModule(file.GetName(), load_base, load_base);
|
|
|
|
return load_base + image_size;
|
|
}
|
|
|
|
AppLoader_NSO::LoadResult AppLoader_NSO::Load(Kernel::Process& process, Core::System& system) {
|
|
if (is_loaded) {
|
|
return {ResultStatus::ErrorAlreadyLoaded, {}};
|
|
}
|
|
|
|
modules.clear();
|
|
|
|
// Load module
|
|
const VAddr base_address = process.PageTable().GetCodeRegionStart();
|
|
if (!LoadModule(process, system, *file, base_address, true, true)) {
|
|
return {ResultStatus::ErrorLoadingNSO, {}};
|
|
}
|
|
|
|
modules.insert_or_assign(base_address, file->GetName());
|
|
LOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", file->GetName(), base_address);
|
|
|
|
is_loaded = true;
|
|
return {ResultStatus::Success,
|
|
LoadParameters{Kernel::THREADPRIO_DEFAULT, Core::Memory::DEFAULT_STACK_SIZE}};
|
|
}
|
|
|
|
ResultStatus AppLoader_NSO::ReadNSOModules(Modules& modules) {
|
|
modules = this->modules;
|
|
return ResultStatus::Success;
|
|
}
|
|
|
|
} // namespace Loader
|