Merge pull request #77 from georgemoralis/TLS_works

TLS branch WIP
This commit is contained in:
georgemoralis 2024-01-27 19:14:37 +02:00 committed by GitHub
commit acfa56f6bc
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
14 changed files with 624 additions and 273 deletions

View File

@ -147,7 +147,7 @@ add_executable(shadps4
src/emuTimer.h
src/core/hle/libraries/libkernel/time_management.cpp
src/core/hle/libraries/libkernel/time_management.h
)
"src/common/io_file.cpp" "src/common/io_file.h")
create_target_directory_groups(shadps4)

138
src/common/io_file.cpp Normal file
View File

@ -0,0 +1,138 @@
#include "io_file.h"
//#include "helpers.hpp"
#ifdef _MSC_VER
// 64 bit offsets for MSVC
#define fseeko _fseeki64
#define ftello _ftelli64
#define fileno _fileno
#pragma warning(disable : 4996)
#endif
#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif
#ifdef WIN32
#include <io.h> // For _chsize_s
#else
#include <unistd.h> // For ftruncate
#endif
IOFile::IOFile(const std::filesystem::path& path, const char* permissions) : handle(nullptr) {
open(path, permissions);
}
bool IOFile::open(const std::filesystem::path& path, const char* permissions) {
const auto str =
path.string(); // For some reason converting paths directly with c_str() doesn't work
return open(str.c_str(), permissions);
}
bool IOFile::open(const char* filename, const char* permissions) {
// If this IOFile is already bound to an open file descriptor, release the file descriptor
// To avoid leaking it and/or erroneously locking the file
if (isOpen()) {
close();
}
handle = std::fopen(filename, permissions);
return isOpen();
}
void IOFile::close() {
if (isOpen()) {
fclose(handle);
handle = nullptr;
}
}
std::pair<bool, std::size_t> IOFile::read(void* data, std::size_t length, std::size_t dataSize) {
if (!isOpen()) {
return {false, std::numeric_limits<std::size_t>::max()};
}
if (length == 0)
return {true, 0};
return {true, std::fread(data, dataSize, length, handle)};
}
std::pair<bool, std::size_t> IOFile::write(const void* data, std::size_t length,
std::size_t dataSize) {
if (!isOpen()) {
return {false, std::numeric_limits<std::size_t>::max()};
}
if (length == 0) {
return {true, 0};
} else {
return {true, std::fwrite(data, dataSize, length, handle)};
}
}
std::pair<bool, std::size_t> IOFile::readBytes(void* data, std::size_t count) {
return read(data, count, sizeof(std::uint8_t));
}
std::pair<bool, std::size_t> IOFile::writeBytes(const void* data, std::size_t count) {
return write(data, count, sizeof(std::uint8_t));
}
std::optional<std::uint64_t> IOFile::size() {
if (!isOpen())
return {};
std::uint64_t pos = ftello(handle);
if (fseeko(handle, 0, SEEK_END) != 0) {
return {};
}
std::uint64_t size = ftello(handle);
if ((size != pos) && (fseeko(handle, pos, SEEK_SET) != 0)) {
return {};
}
return size;
}
bool IOFile::seek(std::int64_t offset, int origin) {
if (!isOpen() || fseeko(handle, offset, origin) != 0)
return false;
return true;
}
bool IOFile::flush() {
if (!isOpen() || fflush(handle))
return false;
return true;
}
bool IOFile::rewind() {
return seek(0, SEEK_SET);
}
FILE* IOFile::getHandle() {
return handle;
}
void IOFile::setAppDataDir(const std::filesystem::path& dir) {
//if (dir == "")
// Helpers::panic("Failed to set app data directory");
appData = dir;
}
bool IOFile::setSize(std::uint64_t size) {
if (!isOpen())
return false;
bool success;
#ifdef WIN32
success = _chsize_s(_fileno(handle), size) == 0;
#else
success = ftruncate(fileno(handle), size) == 0;
#endif
fflush(handle);
return success;
}

41
src/common/io_file.h Normal file
View File

@ -0,0 +1,41 @@
#pragma once
#include <cstdint>
#include <filesystem>
#include <optional>
class IOFile {
FILE* handle = nullptr;
static inline std::filesystem::path appData =""; // Directory for holding app data. AppData on Windows
public:
IOFile() : handle(nullptr) {}
IOFile(FILE* handle) : handle(handle) {}
IOFile(const std::filesystem::path& path, const char* permissions = "rb");
bool isOpen() {
return handle != nullptr;
}
bool open(const std::filesystem::path& path, const char* permissions = "rb");
bool open(const char* filename, const char* permissions = "rb");
void close();
std::pair<bool, std::size_t> read(void* data, std::size_t length, std::size_t dataSize);
std::pair<bool, std::size_t> readBytes(void* data, std::size_t count);
std::pair<bool, std::size_t> write(const void* data, std::size_t length, std::size_t dataSize);
std::pair<bool, std::size_t> writeBytes(const void* data, std::size_t count);
std::optional<std::uint64_t> size();
bool seek(std::int64_t offset, int origin = SEEK_SET);
bool rewind();
bool flush();
FILE* getHandle();
static void setAppDataDir(const std::filesystem::path& dir);
static std::filesystem::path getAppData() {
return appData;
}
// Sets the size of the file to "size" and returns whether it succeeded or not
bool setSize(std::uint64_t size);
};

View File

@ -19,8 +19,38 @@ void Flush() {
spdlog::details::registry::instance().flush_all();
}
thread_local uint8_t TLS[1024];
uint64_t tls_access(int64_t tls_offset) {
if (tls_offset == 0) {
return (uint64_t)TLS;
}
}
#ifdef _WIN64
static LONG WINAPI ExceptionHandler(PEXCEPTION_POINTERS pExp) noexcept {
auto orig_rip = pExp->ContextRecord->Rip;
while (*(uint8_t *)pExp->ContextRecord->Rip == 0x66) pExp->ContextRecord->Rip++;
if (*(uint8_t *)pExp->ContextRecord->Rip == 0xcd) {
int reg = *(uint8_t *)(pExp->ContextRecord->Rip + 1) - 0x80;
int sizes = *(uint8_t *)(pExp->ContextRecord->Rip + 2);
int pattern_size = sizes & 0xF;
int imm_size = sizes >> 4;
int64_t tls_offset;
if (imm_size == 4)
tls_offset = *(int32_t *)(pExp->ContextRecord->Rip + pattern_size);
else
tls_offset = *(int64_t *)(pExp->ContextRecord->Rip + pattern_size);
(&pExp->ContextRecord->Rax)[reg] = tls_access(tls_offset); /* TLS_ACCESS */
pExp->ContextRecord->Rip += pattern_size + imm_size;
return EXCEPTION_CONTINUE_EXECUTION;
}
pExp->ContextRecord->Rip = orig_rip;
const u32 ec = pExp->ExceptionRecord->ExceptionCode;
switch (ec) {
case EXCEPTION_ACCESS_VIOLATION: {

View File

@ -330,5 +330,14 @@ void videoOutRegisterLib(Core::Loader::SymbolsResolver* sym) {
LIB_FUNCTION("zgXifHT9ErY", "libSceVideoOut", 1, "libSceVideoOut", 0, 0, sceVideoOutIsFlipPending);
LIB_FUNCTION("N5KDtkIjjJ4", "libSceVideoOut", 1, "libSceVideoOut", 0, 0, sceVideoOutUnregisterBuffers);
LIB_FUNCTION("uquVH4-Du78", "libSceVideoOut", 1, "libSceVideoOut", 0, 0, sceVideoOutClose);
// openOrbis appears to have libSceVideoOut_v1 module libSceVideoOut_v1.1
LIB_FUNCTION("Up36PTk687E", "libSceVideoOut", 1, "libSceVideoOut", 1, 1, sceVideoOutOpen);
LIB_FUNCTION("CBiu4mCE1DA", "libSceVideoOut", 1, "libSceVideoOut", 1, 1, sceVideoOutSetFlipRate);
LIB_FUNCTION("HXzjK9yI30k", "libSceVideoOut", 1, "libSceVideoOut", 1, 1, sceVideoOutAddFlipEvent);
LIB_FUNCTION("i6-sR91Wt-4", "libSceVideoOut", 1, "libSceVideoOut", 1, 1, sceVideoOutSetBufferAttribute);
LIB_FUNCTION("w3BY+tAEiQY", "libSceVideoOut", 1, "libSceVideoOut", 1, 1, sceVideoOutRegisterBuffers);
LIB_FUNCTION("U46NwOiJpys", "libSceVideoOut", 1, "libSceVideoOut", 1, 1, sceVideoOutSubmitFlip);
LIB_FUNCTION("SbU3dwp80lQ", "libSceVideoOut", 1, "libSceVideoOut", 1, 1, sceVideoOutGetFlipStatus);
}
} // namespace HLE::Libs::Graphics::VideoOut

View File

@ -4,6 +4,7 @@
#include <vector>
#include "common/fs_file.h"
#include <common/io_file.h>
namespace Core::FileSys {
@ -32,7 +33,7 @@ struct File {
std::atomic_bool isDirectory;
std::string m_host_name;
std::string m_guest_name;
Common::FS::File f;
IOFile f;
//std::vector<Common::FS::DirEntry> dirents;
u32 dirents_index;
std::mutex m_mutex;

View File

@ -2,6 +2,9 @@
#include "common/debug.h"
#include "core/hle/libraries/libkernel/file_system.h"
#include "core/hle/libraries/libs.h"
#include <core/file_sys/fs.h>
#include <common/singleton.h>
#include <core/hle/error_codes.h>
namespace Core::Libraries::LibKernel {
@ -9,10 +12,25 @@ constexpr bool log_file_fs = true; // disable it to disable logging
int PS4_SYSV_ABI sceKernelOpen(const char* path, int flags, u16 mode) {
LOG_INFO_IF(log_file_fs, "sceKernelOpen path = {} flags = {:#x} mode = {:#x}\n", path, flags, mode);
return 0;
auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
auto* mnt = Common::Singleton<Core::FileSys::MntPoints>::Instance();
// only open files support!
u32 handle = h->createHandle();
auto* file = h->getFile(handle);
file->m_guest_name = path;
file->m_host_name = mnt->getHostFile(file->m_guest_name);
bool result = file->f.open(file->m_host_name);
if (!result) {
h->deleteHandle(handle);
return SCE_KERNEL_ERROR_EACCES;
}
file->isOpened = true;
return handle;
}
int PS4_SYSV_ABI open(const char* path, int flags, /* SceKernelMode*/ u16 mode) {
int PS4_SYSV_ABI posix_open(const char* path, int flags, /* SceKernelMode*/ u16 mode) {
LOG_INFO_IF(log_file_fs, "posix open redirect to sceKernelOpen\n");
int result = sceKernelOpen(path, flags, mode);
if (result < 0) {
@ -21,9 +39,25 @@ int PS4_SYSV_ABI open(const char* path, int flags, /* SceKernelMode*/ u16 mode)
return result;
}
size_t PS4_SYSV_ABI _readv(int d, const SceKernelIovec* iov, int iovcnt) {
auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
auto* file = h->getFile(d);
size_t total_read = 0;
file->m_mutex.lock();
for (int i = 0; i < iovcnt; i++) {
total_read += file->f.readBytes(iov[i].iov_base,iov[i].iov_len).second;
}
file->m_mutex.unlock();
return total_read;
}
void fileSystemSymbolsRegister(Loader::SymbolsResolver* sym) {
LIB_FUNCTION("1G3lF1Gg1k8", "libkernel", 1, "libkernel", 1, 1, sceKernelOpen);
LIB_FUNCTION("wuCroIGjt2g", "libScePosix", 1, "libkernel", 1, 1, open);
LIB_FUNCTION("wuCroIGjt2g", "libScePosix", 1, "libkernel", 1, 1, posix_open);
LIB_FUNCTION("+WRlkKjZvag", "libkernel", 1, "libkernel", 1, 1, _readv);
// openOrbis (to check if it is valid out of OpenOrbis
LIB_FUNCTION("6c3rCVE-fTU", "libkernel", 1, "libkernel", 1, 1, posix_open); // _open shoudld be equal to open function
}
} // namespace Core::Libraries::LibKernel

View File

@ -8,9 +8,14 @@ class SymbolsResolver;
namespace Core::Libraries::LibKernel {
struct SceKernelIovec {
void *iov_base;
size_t iov_len;
};
int PS4_SYSV_ABI sceKernelOpen(const char *path, int flags, /* SceKernelMode*/ u16 mode);
int PS4_SYSV_ABI open(const char *path, int flags, /* SceKernelMode*/ u16 mode);
int PS4_SYSV_ABI posix_open(const char *path, int flags, /* SceKernelMode*/ u16 mode);
void fileSystemSymbolsRegister(Loader::SymbolsResolver *sym);

View File

@ -14,11 +14,14 @@
#ifdef _WIN64
#include <windows.h>
#include <io.h>
#endif
#include "thread_management.h"
namespace Core::Libraries::LibKernel {
constexpr bool log_libkernel_file = true; // disable it to disable logging
static u64 g_stack_chk_guard = 0xDEADBEEF54321ABC; // dummy return
int32_t PS4_SYSV_ABI sceKernelReleaseDirectMemory(off_t start, size_t len) {
@ -30,9 +33,72 @@ static PS4_SYSV_ABI void stack_chk_fail() { BREAKPOINT(); }
int PS4_SYSV_ABI sceKernelMunmap(void* addr, size_t len) { BREAKPOINT(); }
void PS4_SYSV_ABI sceKernelUsleep(unsigned int microseconds) { std::this_thread::sleep_for(std::chrono::microseconds(microseconds)); }
struct iovec {
void* iov_base; /* Base address. */
size_t iov_len; /* Length. */
};
size_t PS4_SYSV_ABI _writev(int fd, const struct iovec* iov, int iovcn) {
// weird it gives fd ==0 and writes to stdout , i am not sure if it that is valid (found in openorbis)
size_t total_written = 0;
for (int i = 0; i < iovcn; i++) {
total_written += ::fwrite(iov[i].iov_base, 1, iov[i].iov_len, stdout);
}
return total_written;
}
static thread_local int libc_error;
int* PS4_SYSV_ABI __Error() { return &libc_error; }
#define PROT_READ 0x1
#define PROT_WRITE 0x2
int PS4_SYSV_ABI sceKernelMmap(void* addr, u64 len, int prot, int flags, int fd, off_t offset, void** res) {
PRINT_FUNCTION_NAME();
if (prot > 3) // READ,WRITE or bitwise READ | WRITE supported
{
LOG_ERROR_IF(log_libkernel_file, "sceKernelMmap prot ={} not supported\n", prot);
}
DWORD flProtect;
if (prot & PROT_WRITE) {
flProtect = PAGE_READWRITE;
}
off_t end = len + offset;
HANDLE mmap_fd, h;
if (fd == -1)
mmap_fd = INVALID_HANDLE_VALUE;
else
mmap_fd = (HANDLE)_get_osfhandle(fd);
h = CreateFileMapping(mmap_fd, NULL, flProtect, 0, end, NULL);
int k = GetLastError();
if (NULL == h) return -1;
DWORD dwDesiredAccess;
if (prot & PROT_WRITE)
dwDesiredAccess = FILE_MAP_WRITE;
else
dwDesiredAccess = FILE_MAP_READ;
void* ret = MapViewOfFile(h, dwDesiredAccess, 0, offset, len);
if (ret == NULL) {
CloseHandle(h);
ret = nullptr;
}
*res = ret;
return 0;
}
PS4_SYSV_ABI void* posix_mmap(void* addr, u64 len, int prot, int flags, int fd, u64 offset) {
void* ptr;
LOG_INFO_IF(log_libkernel_file, "posix mmap redirect to sceKernelMmap\n");
// posix call the difference is that there is a different behaviour when it doesn't return 0 or SCE_OK
int result = sceKernelMmap(addr, len, prot, flags, fd, offset, &ptr);
if (result != 0) {
BREAKPOINT();
}
return ptr;
}
void LibKernel_Register(Loader::SymbolsResolver* sym) {
// obj
LIB_OBJ("f7uOxY9mM1U", "libkernel", 1, "libkernel", 1, 1, &g_stack_chk_guard);
@ -49,6 +115,9 @@ void LibKernel_Register(Loader::SymbolsResolver* sym) {
LIB_FUNCTION("WslcK1FQcGI", "libkernel", 1, "libkernel", 1, 1, Kernel::sceKernelIsNeoMode);
LIB_FUNCTION("Ou3iL1abvng", "libkernel", 1, "libkernel", 1, 1, stack_chk_fail);
LIB_FUNCTION("9BcDykPmo1I", "libkernel", 1, "libkernel", 1, 1, __Error);
LIB_FUNCTION("BPE9s9vQQXo", "libkernel", 1, "libkernel", 1, 1, posix_mmap);
LIB_FUNCTION("1jfXLRVzisc", "libkernel", 1, "libkernel", 1, 1, sceKernelUsleep);
LIB_FUNCTION("YSHRBRLn2pI", "libkernel", 1, "libkernel", 1, 1, _writev);
Core::Libraries::LibKernel::fileSystemSymbolsRegister(sym);
Core::Libraries::LibKernel::timeSymbolsRegister(sym);

View File

@ -95,8 +95,62 @@ Module* Linker::FindModule(/*u32 id*/)
return &m_modules[0];
}
void Linker::LoadModuleToMemory(Module* m)
{
struct TLSPattern{
uint8_t pattern[5];
uint8_t pattern_size;
uint8_t imm_size;
uint8_t target_reg;
};
constexpr TLSPattern tls_patterns[] = {
{{0x64, 0x48, 0xA1}, 3, 8, 0}, // 64 48 A1 | 00 00 00 00 00 00 00 00 # mov rax, qword ptr fs:[64b imm]
{{0x64, 0x48, 0x8B, 0x4, 0x25}, 5, 4, 0}, // 64 48 8B 04 25 | 00 00 00 00 # mov rax,qword ptr fs:[0]
{{0x64, 0x48, 0x8B, 0xC, 0x25}, 5, 4, 1}, // rcx
{{0x64, 0x48, 0x8B, 0x14, 0x25}, 5, 4, 2}, // rdx
{{0x64, 0x48, 0x8B, 0x1C, 0x25}, 5, 4, 3}, // rbx
{{0x64, 0x48, 0x8B, 0x24, 0x25}, 5, 4, 4}, // rsp
{{0x64, 0x48, 0x8B, 0x2C, 0x25}, 5, 4, 5}, // rbp
{{0x64, 0x48, 0x8B, 0x34, 0x25}, 5, 4, 6}, // rsi
{{0x64, 0x48, 0x8B, 0x3C, 0x25}, 5, 4, 7}, // rdi
{{0x64, 0x4C, 0x8B, 0x4, 0x25}, 5, 4, 8}, // r8
{{0x64, 0x4C, 0x8B, 0xC, 0x25}, 5, 4, 9}, // r9
{{0x64, 0x4C, 0x8B, 0x14, 0x25}, 5, 4, 10},// r10
{{0x64, 0x4C, 0x8B, 0x1C, 0x25}, 5, 4, 11},// r11
{{0x64, 0x4C, 0x8B, 0x24, 0x25}, 5, 4, 12},// r12
{{0x64, 0x4C, 0x8B, 0x2C, 0x25}, 5, 4, 13},// r13
{{0x64, 0x4C, 0x8B, 0x34, 0x25}, 5, 4, 14},// r14
{{0x64, 0x4C, 0x8B, 0x3C, 0x25}, 5, 4, 15},// r15
};
void PatchTLS(u64 segment_addr, u64 segment_size) {
uint8_t* code = (uint8_t*)segment_addr;
auto remaining_size = segment_size;
while (remaining_size) {
for (auto& tls_pattern : tls_patterns) {
auto total_size = tls_pattern.pattern_size + tls_pattern.imm_size;
if (remaining_size >= total_size) {
if (memcmp(code, tls_pattern.pattern, tls_pattern.pattern_size) == 0) {
if (tls_pattern.imm_size == 4)
printf("PATTERN32 FOUND @ %p, reg: %d offset: %X\n", code, tls_pattern.target_reg, *(uint32_t*)(code + tls_pattern.pattern_size));
else
printf("PATTERN64 FOUND @ %p, reg: %d offset: %lX\n", code, tls_pattern.target_reg, *(uint64_t*)(code + tls_pattern.pattern_size));
code[0] = 0xcd;
code[1] = 0x80 + tls_pattern.target_reg;
code[2] = tls_pattern.pattern_size | (tls_pattern.imm_size << 4);
code += total_size - 1;
remaining_size -= total_size - 1;
break;
}
}
}
code++;
remaining_size--;
}
}
void Linker::LoadModuleToMemory(Module* m) {
//get elf header, program header
const auto elf_header = m->elf.GetElfHeader();
const auto elf_pheader = m->elf.GetProgramHeader();
@ -130,6 +184,10 @@ void Linker::LoadModuleToMemory(Module* m)
LOG_INFO_IF(debug_loader, "segment_mode ..........: {}\n", segment_mode);
m->elf.LoadSegment(segment_addr, elf_pheader[i].p_offset, segment_file_size);
if (elf_pheader[i].p_flags & PF_EXEC) {
PatchTLS(segment_addr, segment_file_size);
}
}
else
{
@ -158,29 +216,17 @@ void Linker::LoadModuleToMemory(Module* m)
LOG_ERROR_IF(debug_loader, "p_filesz==0 in type {}\n", m->elf.ElfPheaderTypeStr(elf_pheader[i].p_type));
}
break;
case PT_TLS:
m->tls.image_virtual_addr = elf_pheader[i].p_vaddr + m->base_virtual_addr;
m->tls.image_size = get_aligned_size(elf_pheader[i]);
LOG_INFO_IF(debug_loader, "tls virtual address ={:#x}\n", m->tls.image_virtual_addr);
LOG_INFO_IF(debug_loader, "tls image size ={}\n", m->tls.image_size);
break;
default:
LOG_ERROR_IF(debug_loader, "Unimplemented type {}\n", m->elf.ElfPheaderTypeStr(elf_pheader[i].p_type));
}
}
LOG_INFO_IF(debug_loader, "program entry addr ..........: {:#018x}\n", m->elf.GetElfEntry() + m->base_virtual_addr);
auto* rt1 = reinterpret_cast<uint8_t*>(m->elf.GetElfEntry() + m->base_virtual_addr);
ZyanU64 runtime_address = m->elf.GetElfEntry() + m->base_virtual_addr;
// Loop over the instructions in our buffer.
ZyanUSize offset = 0;
ZydisDisassembledInstruction instruction;
while (ZYAN_SUCCESS(ZydisDisassembleIntel(
/* machine_mode: */ ZYDIS_MACHINE_MODE_LONG_64,
/* runtime_address: */ runtime_address,
/* buffer: */ rt1 + offset,
/* length: */ sizeof(rt1) - offset,
/* instruction: */ &instruction
))) {
fmt::print("{:#x}" PRIX64 " {}\n", runtime_address, instruction.text);
offset += instruction.info.length;
runtime_address += instruction.info.length;
}
}
void Linker::LoadDynamicInfo(Module* m)
@ -316,7 +362,7 @@ void Linker::LoadDynamicInfo(Module* m)
break;
case DT_SCE_IMPORT_LIB_ATTR:
//The upper 32-bits should contain the module index multiplied by 0x10000. The lower 32-bits should be a constant 0x9.
LOG_INFO_IF(debug_loader, "unsupported DT_SCE_IMPORT_LIB_ATTR value = ..........: {:#018x}\n", dyn->d_un.d_val);
LOG_INFO_IF(debug_loader, "unsupported DT_SCE_IMPORT_LIB_ATTR value = ......: {:#018x}\n", dyn->d_un.d_val);
break;
case DT_SCE_ORIGINAL_FILENAME:
m->dynamic_info.filename = m->dynamic_info.str_table + dyn->d_un.d_val;
@ -507,7 +553,7 @@ static void relocate(u32 idx, elf_relocation* rel, Module* m, bool isJmpRel) {
case R_X86_64_RELATIVE:
if (symbol != 0) // should be always zero
{
LOG_INFO_IF(debug_loader, "R_X86_64_RELATIVE symbol not zero = {:#010x}\n", type, symbol);
//LOG_INFO_IF(debug_loader, "R_X86_64_RELATIVE symbol not zero = {:#010x}\n", type, symbol);//found it openorbis but i am not sure it worth logging
}
rel_value = rel_base_virtual_addr + addend;
rel_isResolved = true;

View File

@ -43,6 +43,11 @@ struct LibraryInfo {
std::string enc_id;
};
struct PS4ThreadLocal {
u64 image_virtual_addr = 0;
u64 image_size = 0;
u64 handler_virtual_addr = 0;
};
struct DynamicModuleInfo {
void* hash_table = nullptr;
u64 hash_table_size = 0;
@ -99,6 +104,8 @@ struct Module {
Loader::SymbolsResolver export_sym;
Loader::SymbolsResolver import_sym;
PS4ThreadLocal tls;
};
class Linker {

View File

@ -1,21 +1,20 @@
#pragma once
#include <string>
#include <cinttypes>
#include <span>
#include <string>
#include <vector>
#include "common/types.h"
#include "common/fs_file.h"
#include "common/types.h"
struct self_header
{
struct self_header {
static const u32 signature = 0x1D3D154Fu;
u32 magic;
u08 version;
u08 mode;
u08 endian;// 1 is little endian
u08 endian; // 1 is little endian
u08 attributes;
u08 category;
u08 program_type;
@ -25,34 +24,31 @@ struct self_header
u32 file_size;
u32 padding2;
u16 segment_count;
u16 unknown1A; //always 0x22
u16 unknown1A; // always 0x22
u32 padding3;
};
struct self_segment_header
{
struct self_segment_header {
bool IsBlocked() const {
return (flags & 0x800) != 0;//0 or 0x800
return (flags & 0x800) != 0; // 0 or 0x800
}
u32 GetId() const {
return (flags >> 20u) & 0xFFFu;
}
u32 GetId() const { return (flags >> 20u) & 0xFFFu; }
bool IsOrdered() const {
return (flags & 1) != 0;//0 or 1
return (flags & 1) != 0; // 0 or 1
}
bool IsEncrypted() const {
return (flags & 2) != 0;//0 or 2
return (flags & 2) != 0; // 0 or 2
}
bool IsSigned() const {
return (flags & 4) != 0;//0 or 4
return (flags & 4) != 0; // 0 or 4
}
bool IsCompressed() const {
return (flags & 8) != 0;//0 or 8
return (flags & 8) != 0; // 0 or 8
}
u64 flags;
@ -61,8 +57,7 @@ struct self_segment_header
u64 memory_size;
};
constexpr u08 EI_MAG0 = 0;/* e_ident[] indexes */
constexpr u08 EI_MAG0 = 0; /* e_ident[] indexes */
constexpr u08 EI_MAG1 = 1;
constexpr u08 EI_MAG2 = 2;
constexpr u08 EI_MAG3 = 3;
@ -184,32 +179,15 @@ typedef enum : u16 {
EM_UNICORE = 110 /* Microprocessor series from PKU-Unity Ltd. and MPRC */
} e_machine_es;
typedef enum :u32 {
EV_NONE = 0x0,
EV_CURRENT = 0x1
} e_version_es;
typedef enum : u32 { EV_NONE = 0x0, EV_CURRENT = 0x1 } e_version_es;
typedef enum : u08 { ELF_CLASS_NONE = 0x0, ELF_CLASS_32 = 0x1, ELF_CLASS_64 = 0x2, ELF_CLASS_NUM = 0x3 } ident_class_es;
typedef enum : u08 { ELF_DATA_NONE = 0x0, ELF_DATA_2LSB = 0x1, ELF_DATA_2MSB = 0x2, ELF_DATA_NUM = 0x3 } ident_endian_es;
typedef enum : u08 { ELF_VERSION_NONE = 0x0, ELF_VERSION_CURRENT = 0x1, ELF_VERSION_NUM = 0x2 } ident_version_es;
typedef enum : u08 {
ELF_CLASS_NONE =0x0,
ELF_CLASS_32 =0x1,
ELF_CLASS_64 =0x2,
ELF_CLASS_NUM =0x3
} ident_class_es;
typedef enum : u08 {
ELF_DATA_NONE = 0x0,
ELF_DATA_2LSB = 0x1,
ELF_DATA_2MSB = 0x2,
ELF_DATA_NUM = 0x3
} ident_endian_es;
typedef enum :u08 {
ELF_VERSION_NONE = 0x0,
ELF_VERSION_CURRENT = 0x1,
ELF_VERSION_NUM = 0x2
} ident_version_es;
typedef enum :u08 {
ELF_OSABI_NONE = 0x0, /* No extensions or unspecified */
ELF_OSABI_HPUX = 0x1, /* Hewlett-Packard HP-UX */
ELF_OSABI_NETBSD = 0x2, /* NetBSD */
@ -229,11 +207,11 @@ typedef enum :u08 {
ELF_OSABI_STANDALONE = 0xFF /* Standalone (embedded applications) */
} ident_osabi_es;
typedef enum :u08 {
ELF_ABI_VERSION_AMDGPU_HSA_V2=0x0,
ELF_ABI_VERSION_AMDGPU_HSA_V3=0x1,
ELF_ABI_VERSION_AMDGPU_HSA_V4=0x2,
ELF_ABI_VERSION_AMDGPU_HSA_V5=0x3
typedef enum : u08 {
ELF_ABI_VERSION_AMDGPU_HSA_V2 = 0x0,
ELF_ABI_VERSION_AMDGPU_HSA_V3 = 0x1,
ELF_ABI_VERSION_AMDGPU_HSA_V4 = 0x2,
ELF_ABI_VERSION_AMDGPU_HSA_V5 = 0x3
} ident_abiversion_es;
struct elf_ident {
@ -246,8 +224,7 @@ struct elf_ident {
u08 pad[6];
};
struct elf_header
{
struct elf_header {
static const u32 signature = 0x7F454C46u;
elf_ident e_ident; /* ELF identification */
@ -306,8 +283,7 @@ typedef enum : u32 {
PF_READ_WRITE_EXEC = 0x7
} elf_program_flags;
struct elf_program_header
{
struct elf_program_header {
elf_program_type p_type; /* Type of segment */
elf_program_flags p_flags; /* Segment attributes */
u64 p_offset; /* Offset in file */
@ -318,8 +294,7 @@ struct elf_program_header
u64 p_align; /* Alignment of segment */
};
struct elf_section_header
{
struct elf_section_header {
u32 sh_name; /* Section name */
u32 sh_type; /* Section type */
u64 sh_flags; /* Section attributes */
@ -332,7 +307,7 @@ struct elf_section_header
u64 sh_entsize; /* Size of entries, if section has table */
};
typedef enum :u64 {
typedef enum : u64 {
PT_FAKE = 0x1,
PT_NPDRM_EXEC = 0x4,
PT_NPDRM_DYNLIB = 0x5,
@ -343,8 +318,7 @@ typedef enum :u64 {
PT_SECURE_KERNEL = 0xF
} program_type_es;
struct elf_program_id_header
{
struct elf_program_id_header {
u64 authid;
program_type_es program_type;
u64 appver;
@ -389,12 +363,9 @@ constexpr s64 DT_SCE_STRSZ = 0x61000037;
constexpr s64 DT_SCE_SYMTAB = 0x61000039;
constexpr s64 DT_SCE_SYMTABSZ = 0x6100003f;
struct elf_dynamic
{
struct elf_dynamic {
s64 d_tag;
union
{
union {
u64 d_val;
u64 d_ptr;
} d_un;
@ -412,7 +383,7 @@ constexpr u08 STT_FILE = 4;
constexpr u08 STT_COMMON = 5;
constexpr u08 STT_TLS = 6;
constexpr u08 STT_LOOS = 10;
constexpr u08 STT_SCE = 11; //module_start/module_stop
constexpr u08 STT_SCE = 11; // module_start/module_stop
constexpr u08 STT_HIOS = 12;
constexpr u08 STT_LOPRO = 13;
constexpr u08 STT_SPARC_REGISTER = 13;
@ -423,8 +394,7 @@ constexpr u08 STV_INTERNAL = 1;
constexpr u08 STV_HIDDEN = 2;
constexpr u08 STV_PROTECTED = 3;
struct elf_symbol
{
struct elf_symbol {
u08 GetBind() const { return st_info >> 4u; }
u08 GetType() const { return st_info & 0xfu; }
u08 GetVisibility() const { return st_other & 3u; }
@ -437,8 +407,7 @@ struct elf_symbol
u64 st_size;
};
struct elf_relocation
{
struct elf_relocation {
u32 GetSymbol() const { return static_cast<u32>(rel_info >> 32u); }
u32 GetType() const { return static_cast<u32>(rel_info & 0xffffffff); }
@ -447,8 +416,10 @@ struct elf_relocation
s64 rel_addend;
};
constexpr u32 R_X86_64_64 = 1; // Direct 64 bit
constexpr u32 R_X86_64_GLOB_DAT = 6;
constexpr u32 R_X86_64_JUMP_SLOT = 7; // Create PLT entry
constexpr u32 R_X86_64_RELATIVE = 8; // Adjust by program base
constexpr u32 R_X86_64_DTPMOD64 = 16;
namespace Core::Loader {
@ -457,30 +428,20 @@ class Elf {
Elf() = default;
virtual ~Elf();
void Open(const std::string & file_name);
void Open(const std::string& file_name);
bool isSelfFile() const;
bool isElfFile() const;
void DebugDump();
[[nodiscard]] self_header GetSElfHeader() const {
return m_self;
}
[[nodiscard]] self_header GetSElfHeader() const { return m_self; }
[[nodiscard]] elf_header GetElfHeader() const {
return m_elf_header;
}
[[nodiscard]] elf_header GetElfHeader() const { return m_elf_header; }
[[nodiscard]] std::span<const elf_program_header> GetProgramHeader() const {
return m_elf_phdr;
}
[[nodiscard]] std::span<const elf_program_header> GetProgramHeader() const { return m_elf_phdr; }
[[nodiscard]] std::span<const self_segment_header> GetSegmentHeader() const {
return m_self_segments;
}
[[nodiscard]] std::span<const self_segment_header> GetSegmentHeader() const { return m_self_segments; }
[[nodiscard]] u64 GetElfEntry() const {
return m_elf_header.e_entry;
}
[[nodiscard]] u64 GetElfEntry() const { return m_elf_header.e_entry; }
std::string SElfHeaderStr();
std::string SELFSegHeader(u16 no);

View File

@ -1,6 +1,7 @@
#include "common/log.h"
#include "core/virtual_memory.h"
#include "common/log.h"
#ifdef _WIN64
#include <windows.h>
#else
@ -107,8 +108,7 @@ bool memory_patch(u64 vaddr, u64 value) {
memory_protect(vaddr, 8, old_mode, nullptr);
// if mode is executable flush it so insure that cpu finds it
if ((old_mode == MemoryMode::Execute || old_mode == MemoryMode::ExecuteRead || old_mode == MemoryMode::ExecuteWrite ||
old_mode == MemoryMode::ExecuteReadWrite)) {
if (containsExecuteMode(old_mode)) {
memory_flush(vaddr, 8);
}

View File

@ -25,4 +25,14 @@ bool memory_protect(u64 address, u64 size, MemoryMode mode, MemoryMode* old_mode
bool memory_flush(u64 address, u64 size);
bool memory_patch(u64 vaddr, u64 value);
inline bool containsExecuteMode(MemoryMode mode) {
switch (mode) {
case MemoryMode::Execute: return true;
case MemoryMode::ExecuteRead: return true;
case MemoryMode::ExecuteWrite: return true;
case MemoryMode::ExecuteReadWrite: return true;
default: return false;
}
}
} // namespace VirtualMemory