georgemoralis
GitHub
commit
acfa56f6bc
|
|
@ -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)
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
@ -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);
|
||||
};
|
||||
|
|
@ -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: {
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
Loading…
Reference in New Issue