steam-frame/FEX-Emu--FEX
1
0 Fork 0
mirror of https://github.com/FEX-Emu/FEX.git synced 2026-10-07 00:00:17 +02:00
Code Issues Packages Projects Releases 66 Wiki Activity
Files
1eb5abb8dbf0c3bd305241c7225803b7ff2a378b
FEX-Emu--FEX/Source/Tools/LinuxEmulation/VDSO_Emulation.cpp
T
Egor Lazarchuk 1eb5abb8db Allocator: rename DetermineVASize to GetHostVABits 
`DetermineVASize` does not return the size of VA, but the number of bits
it can use. Change the naming to make it more self explanatory.
In the mean time also move `HostVASize` global into `GetHostVABits`
since it is not and should not be used directly.
2026-07-05 12:46:41 +01:00

905 lines
30 KiB
C++
Raw Blame History

// SPDX-License-Identifier: MIT
#include "VDSO_Emulation.h"
#include "LinuxSyscalls/Syscalls.h"
#include "LinuxSyscalls/x32/Types.h"
#include <FEXCore/Config/Config.h>
#include <FEXCore/Core/Context.h>
#include <FEXCore/IR/IR.h>
#include <FEXCore/Utils/Allocator.h>
#include <FEXCore/Utils/LogManager.h>
#include <FEXCore/Utils/MathUtils.h>
#include <FEXCore/Utils/SignalScopeGuards.h>
#include <FEXCore/Utils/TypeDefines.h>
#include <FEXCore/fextl/fmt.h>
#include <FEXCore/fextl/map.h>
#include <FEXHeaderUtils/Syscalls.h>
#include <array>
#include <dlfcn.h>
#include <elf.h>
#include <fcntl.h>
#include <filesystem>
#include <sys/auxv.h>
#include <sys/mman.h>
#include <sys/time.h>
#include <unistd.h>
namespace FEX::VDSO {
VDSOEntrypoints VDSOPointers {};
namespace VDSOHandlers {
using TimeType = decltype(::time)*;
using GetTimeOfDayType = decltype(::gettimeofday)*;
using ClockGetTimeType = decltype(::clock_gettime)*;
using ClockGetResType = decltype(::clock_getres)*;
using GetCPUType = decltype(FHU::Syscalls::getcpu)*;
using GetRandomType = ssize_t (*)(void*, size_t, uint32_t, void*, size_t);
TimeType TimePtr;
GetTimeOfDayType GetTimeOfDayPtr;
ClockGetTimeType ClockGetTimePtr;
ClockGetResType ClockGetResPtr;
GetCPUType GetCPUPtr;
GetRandomType GetRandomPtr;
} // namespace VDSOHandlers
using HandlerPtr = void (*)(void*);
namespace x64 {
static uint64_t SyscallRet(uint64_t Result) {
if (Result == -1) {
return -errno;
}
return Result;
}
// glibc handlers
namespace glibc {
static void time(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
time_t* a_0;
uint64_t rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
uint64_t Result = ::time(args->a_0);
args->rv = SyscallRet(Result);
}
static void gettimeofday(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
struct timeval* tv;
struct timezone* tz;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
int Result = ::gettimeofday(args->tv, args->tz);
args->rv = SyscallRet(Result);
}
static void clock_gettime(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
clockid_t clk_id;
struct timespec* tp;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
int Result = ::clock_gettime(args->clk_id, args->tp);
args->rv = SyscallRet(Result);
}
static void clock_getres(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
clockid_t clk_id;
struct timespec* tp;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
int Result = ::clock_getres(args->clk_id, args->tp);
args->rv = SyscallRet(Result);
}
static void getcpu(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
uint32_t* cpu;
uint32_t* node;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
int Result = FHU::Syscalls::getcpu(args->cpu, args->node);
args->rv = SyscallRet(Result);
}
static void getrandom(void* ArgsRV) {
struct vgetrandom_opaque_params {
uint32_t size_of_opaque_state;
uint32_t mmap_prot;
uint32_t mmap_flags;
uint32_t reserved[13];
};
static_assert(sizeof(vgetrandom_opaque_params) == sizeof(uint32_t[16]));
struct __attribute__((packed)) ArgsRV_t {
void* buffer;
size_t len;
uint32_t flags;
vgetrandom_opaque_params* opaque_state;
size_t opaque_len;
ssize_t rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
if (args->buffer == nullptr && args->len == 0 && args->flags == 0 && args->opaque_len == ~0ULL) [[unlikely]] {
// Special case querying for flags
// Since this is the syscall implementation, we need to return valid but unused data.
// This will cause glibc to allocate a page of memory, but it ends up being unused.
args->opaque_state->size_of_opaque_state = FEXCore::Utils::FEX_PAGE_SIZE;
args->opaque_state->mmap_prot = PROT_NONE;
args->opaque_state->mmap_flags = MAP_NORESERVE | MAP_ANONYMOUS | MAP_PRIVATE;
args->rv = 0;
return;
}
int Result = ::syscall(SYS_getrandom, args->buffer, args->len, args->flags);
args->rv = SyscallRet(Result);
}
} // namespace glibc
namespace VDSO {
// VDSO handlers
static void time(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
time_t* a_0;
uint64_t rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
args->rv = VDSOHandlers::TimePtr(args->a_0);
}
static void gettimeofday(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
struct timeval* tv;
struct timezone* tz;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
args->rv = VDSOHandlers::GetTimeOfDayPtr(args->tv, args->tz);
}
static void clock_gettime(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
clockid_t clk_id;
struct timespec* tp;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
args->rv = VDSOHandlers::ClockGetTimePtr(args->clk_id, args->tp);
}
static void clock_getres(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
clockid_t clk_id;
struct timespec* tp;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
args->rv = VDSOHandlers::ClockGetResPtr(args->clk_id, args->tp);
}
static void getcpu(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
uint32_t* cpu;
uint32_t* node;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
args->rv = VDSOHandlers::GetCPUPtr(args->cpu, args->node);
}
static void getrandom(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
void* buffer;
size_t len;
uint32_t flags;
void* opaque_state;
size_t opaque_len;
ssize_t rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
args->rv = VDSOHandlers::GetRandomPtr(args->buffer, args->len, args->flags, args->opaque_state, args->opaque_len);
}
} // namespace VDSO
HandlerPtr Handler_time = FEX::VDSO::x64::glibc::time;
HandlerPtr Handler_gettimeofday = FEX::VDSO::x64::glibc::gettimeofday;
HandlerPtr Handler_clock_gettime = FEX::VDSO::x64::glibc::clock_gettime;
HandlerPtr Handler_clock_getres = FEX::VDSO::x64::glibc::clock_getres;
HandlerPtr Handler_getcpu = FEX::VDSO::x64::glibc::getcpu;
HandlerPtr Handler_getrandom = FEX::VDSO::x64::glibc::getrandom;
} // namespace x64
namespace x32 {
namespace glibc {
static int SyscallRet(int Result) {
if (Result == -1) {
return -errno;
}
return Result;
}
// glibc handlers
static void time(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
HLE::x32::compat_ptr<FEX::HLE::x32::old_time32_t> a_0;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
time_t Host {};
int Result = ::time(&Host);
args->rv = SyscallRet(Result);
if (Result != -1 && args->a_0) {
*args->a_0 = Host;
}
}
static void gettimeofday(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
HLE::x32::compat_ptr<FEX::HLE::x32::timeval32> tv;
HLE::x32::compat_ptr<struct timezone> tz;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
struct timeval tv64 {};
struct timeval* tv_ptr {};
if (args->tv) {
tv_ptr = &tv64;
}
int Result = ::gettimeofday(tv_ptr, args->tz);
args->rv = SyscallRet(Result);
if (Result != -1 && args->tv) {
*args->tv = tv64;
}
}
static void clock_gettime(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
clockid_t clk_id;
HLE::x32::compat_ptr<HLE::x32::timespec32> tp;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
struct timespec tp64 {};
int Result = ::clock_gettime(args->clk_id, &tp64);
args->rv = SyscallRet(Result);
if (Result != -1 && args->tp) {
*args->tp = tp64;
}
}
static void clock_gettime64(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
clockid_t clk_id;
HLE::x32::compat_ptr<struct timespec> tp;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
int Result = ::clock_gettime(args->clk_id, args->tp);
args->rv = SyscallRet(Result);
}
static void clock_getres(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
clockid_t clk_id;
HLE::x32::compat_ptr<HLE::x32::timespec32> tp;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
struct timespec tp64 {};
int Result = ::clock_getres(args->clk_id, &tp64);
args->rv = SyscallRet(Result);
if (Result != -1 && args->tp) {
*args->tp = tp64;
}
}
static void getcpu(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
HLE::x32::compat_ptr<uint32_t> cpu;
HLE::x32::compat_ptr<uint32_t> node;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
int Result = FHU::Syscalls::getcpu(args->cpu, args->node);
args->rv = SyscallRet(Result);
}
} // namespace glibc
namespace VDSO {
static bool SyscallErr(uint64_t Result) {
return Result >= -4095;
}
// VDSO handlers
static void time(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
HLE::x32::compat_ptr<FEX::HLE::x32::old_time32_t> a_0;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
time_t Host {};
uint64_t Result = VDSOHandlers::TimePtr(&Host);
args->rv = Result;
if (!SyscallErr(Result) && args->a_0) {
*args->a_0 = Host;
}
}
static void gettimeofday(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
HLE::x32::compat_ptr<FEX::HLE::x32::timeval32> tv;
HLE::x32::compat_ptr<struct timezone> tz;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
struct timeval tv64 {};
struct timeval* tv_ptr {};
if (args->tv) {
tv_ptr = &tv64;
}
uint64_t Result = VDSOHandlers::GetTimeOfDayPtr(tv_ptr, args->tz);
args->rv = Result;
if (!SyscallErr(Result) && args->tv) {
*args->tv = tv64;
}
}
static void clock_gettime(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
clockid_t clk_id;
HLE::x32::compat_ptr<HLE::x32::timespec32> tp;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
struct timespec tp64 {};
uint64_t Result = VDSOHandlers::ClockGetTimePtr(args->clk_id, &tp64);
args->rv = Result;
if (!SyscallErr(Result) && args->tp) {
*args->tp = tp64;
}
}
static void clock_gettime64(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
clockid_t clk_id;
HLE::x32::compat_ptr<struct timespec> tp;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
args->rv = VDSOHandlers::ClockGetTimePtr(args->clk_id, args->tp);
}
static void clock_getres(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
clockid_t clk_id;
HLE::x32::compat_ptr<HLE::x32::timespec32> tp;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
struct timespec tp64 {};
uint64_t Result = VDSOHandlers::ClockGetResPtr(args->clk_id, &tp64);
args->rv = Result;
if (!SyscallErr(Result) && args->tp) {
*args->tp = tp64;
}
}
static void getcpu(void* ArgsRV) {
struct __attribute__((packed)) ArgsRV_t {
HLE::x32::compat_ptr<uint32_t> cpu;
HLE::x32::compat_ptr<uint32_t> node;
int rv;
}* args = reinterpret_cast<ArgsRV_t*>(ArgsRV);
args->rv = VDSOHandlers::GetCPUPtr(args->cpu, args->node);
}
} // namespace VDSO
HandlerPtr Handler_time = FEX::VDSO::x32::glibc::time;
HandlerPtr Handler_gettimeofday = FEX::VDSO::x32::glibc::gettimeofday;
HandlerPtr Handler_clock_gettime = FEX::VDSO::x32::glibc::clock_gettime;
HandlerPtr Handler_clock_gettime64 = FEX::VDSO::x32::glibc::clock_gettime64;
HandlerPtr Handler_clock_getres = FEX::VDSO::x32::glibc::clock_getres;
HandlerPtr Handler_getcpu = FEX::VDSO::x32::glibc::getcpu;
} // namespace x32
class VDSOParser final {
public:
VDSOParser(const uint8_t* HeaderBase);
void* FindSymbol(std::string_view Name) const {
auto it = Symbols.find(Name);
if (it == Symbols.end()) {
return nullptr;
}
return it->second;
}
private:
fextl::map<std::string_view, void*> Symbols;
};
VDSOParser::VDSOParser(const uint8_t* HeaderBase) {
// Minimal ELF parser that only knows how to scan for dynamic symbols from VDSO.
auto Header = reinterpret_cast<const Elf64_Ehdr*>(HeaderBase);
auto SectionHeaderOffset = Header->e_shoff;
auto SectionHeaderCount = Header->e_shnum;
auto SectionHeaders = reinterpret_cast<const Elf64_Shdr*>(&HeaderBase[SectionHeaderOffset]);
// Scan for the symbol and string headers.
const Elf64_Shdr* DynamicSymbolHeader {};
const Elf64_Shdr* DynamicStringHeader {};
for (size_t i = 0; i < SectionHeaderCount; ++i) {
if (DynamicSymbolHeader && DynamicStringHeader) {
// Found both headers.
break;
}
if (SectionHeaders[i].sh_type == SHT_DYNSYM) {
// Dynamic symbol header found.
DynamicSymbolHeader = &SectionHeaders[i];
}
if (SectionHeaders[i].sh_type == SHT_STRTAB && SectionHeaders[i].sh_addr) {
// Dynamic string header found.
DynamicStringHeader = &SectionHeaders[i];
}
}
if (!DynamicSymbolHeader || !DynamicStringHeader) {
LogMan::Msg::DFmt("Couldn't parse host VDSO symbols. Falling back to glibc implementations.");
return;
}
auto NumberOfDynamicSymbols = DynamicSymbolHeader->sh_size / DynamicSymbolHeader->sh_entsize;
const char* DynamicStringTable = reinterpret_cast<const char*>(&HeaderBase[DynamicStringHeader->sh_offset]);
// Scan all the symbols and populate the look-up table.
for (size_t i = 0; i < NumberOfDynamicSymbols; ++i) {
auto Offset = DynamicSymbolHeader->sh_offset + (i * DynamicSymbolHeader->sh_entsize);
auto Symbol = reinterpret_cast<const Elf64_Sym*>(&HeaderBase[Offset]);
if (Symbol->st_info != 0) {
// Save the symbol.
const char* Name = &DynamicStringTable[Symbol->st_name];
auto SymbolPtr = HeaderBase + Symbol->st_value;
Symbols[Name] = const_cast<void*>(static_cast<const void*>(SymbolPtr));
}
}
}
void LoadHostVDSO() {
// Linux gives the VDSO ELF header base in the auxv value AT_SYSINFO_EHDR.
auto VDSOHeader = ::getauxval(AT_SYSINFO_EHDR);
if (!VDSOHeader) {
// We couldn't load VDSO, fallback to C implementations. Which will still be faster than emulated libc versions.
LogMan::Msg::IFmt("linux-vdso implementation falling back to libc. Consider enabling VDSO in your kernel.");
return;
}
auto VDSO = VDSOParser(reinterpret_cast<const uint8_t*>(VDSOHeader));
auto SymbolPtr = VDSO.FindSymbol("__kernel_time");
if (!SymbolPtr) {
SymbolPtr = VDSO.FindSymbol("__vdso_time");
}
if (SymbolPtr) {
VDSOHandlers::TimePtr = reinterpret_cast<VDSOHandlers::TimeType>(SymbolPtr);
x64::Handler_time = x64::VDSO::time;
x32::Handler_time = x32::VDSO::time;
}
SymbolPtr = VDSO.FindSymbol("__kernel_gettimeofday");
if (!SymbolPtr) {
SymbolPtr = VDSO.FindSymbol("__vdso_gettimeofday");
}
if (SymbolPtr) {
VDSOHandlers::GetTimeOfDayPtr = reinterpret_cast<VDSOHandlers::GetTimeOfDayType>(SymbolPtr);
x64::Handler_gettimeofday = x64::VDSO::gettimeofday;
x32::Handler_gettimeofday = x32::VDSO::gettimeofday;
}
SymbolPtr = VDSO.FindSymbol("__kernel_clock_gettime");
if (!SymbolPtr) {
SymbolPtr = VDSO.FindSymbol("__vdso_clock_gettime");
}
if (SymbolPtr) {
VDSOHandlers::ClockGetTimePtr = reinterpret_cast<VDSOHandlers::ClockGetTimeType>(SymbolPtr);
x64::Handler_clock_gettime = x64::VDSO::clock_gettime;
x32::Handler_clock_gettime = x32::VDSO::clock_gettime;
x32::Handler_clock_gettime64 = x32::VDSO::clock_gettime64;
}
SymbolPtr = VDSO.FindSymbol("__kernel_clock_getres");
if (!SymbolPtr) {
SymbolPtr = VDSO.FindSymbol("__vdso_clock_getres");
}
if (SymbolPtr) {
VDSOHandlers::ClockGetResPtr = reinterpret_cast<VDSOHandlers::ClockGetResType>(SymbolPtr);
x64::Handler_clock_getres = x64::VDSO::clock_getres;
x32::Handler_clock_getres = x32::VDSO::clock_getres;
}
SymbolPtr = VDSO.FindSymbol("__kernel_getcpu");
if (!SymbolPtr) {
SymbolPtr = VDSO.FindSymbol("__vdso_getcpu");
}
if (SymbolPtr) {
VDSOHandlers::GetCPUPtr = reinterpret_cast<VDSOHandlers::GetCPUType>(SymbolPtr);
x64::Handler_getcpu = x64::VDSO::getcpu;
x32::Handler_getcpu = x32::VDSO::getcpu;
}
SymbolPtr = VDSO.FindSymbol("__kernel_getrandom");
if (!SymbolPtr) {
SymbolPtr = VDSO.FindSymbol("__vdso_getrandom");
}
if (SymbolPtr) {
VDSOHandlers::GetRandomPtr = reinterpret_cast<VDSOHandlers::GetRandomType>(SymbolPtr);
x64::Handler_getrandom = x64::VDSO::getrandom;
// 32-bit doesn't have getrandom vdso
}
}
static std::array<FEXCore::IR::ThunkDefinition, 7> VDSODefinitions = {{
{
// sha256(libVDSO:time)
{0x37, 0x63, 0x46, 0xb0, 0x79, 0x06, 0x5f, 0x9d, 0x00, 0xb6, 0x8d, 0xfd, 0x9e, 0x4a, 0x62, 0xcd,
0x1e, 0x6c, 0xcc, 0x22, 0xcd, 0xb2, 0xc0, 0x17, 0x7d, 0x42, 0x6a, 0x40, 0xd1, 0xeb, 0xfa, 0xe0},
nullptr,
},
{
// sha256(libVDSO:gettimeofday)
{0x77, 0x2a, 0xde, 0x1c, 0x13, 0x2d, 0xe9, 0x48, 0xaf, 0xe0, 0xba, 0xcc, 0x6a, 0x89, 0xff, 0xca,
0x4a, 0xdc, 0xd5, 0x63, 0x2c, 0xc5, 0x62, 0x8b, 0x5d, 0xde, 0x0b, 0x15, 0x35, 0xc6, 0xc7, 0x14},
nullptr,
},
{
// sha256(libVDSO:clock_gettime)
{0x3c, 0x96, 0x9b, 0x2d, 0xc3, 0xad, 0x2b, 0x3b, 0x9c, 0x4e, 0x4d, 0xca, 0x1c, 0xe8, 0x18, 0x4a,
0x12, 0x8a, 0xe4, 0xc1, 0x56, 0x92, 0x73, 0xce, 0x65, 0x85, 0x5f, 0x65, 0x7e, 0x94, 0x26, 0xbe},
nullptr,
},
{
// sha256(libVDSO:clock_gettime64)
{0xba, 0xe9, 0x6d, 0x30, 0xc0, 0x68, 0xc6, 0xd7, 0x59, 0x04, 0xf7, 0x10, 0x06, 0x72, 0x88, 0xfd,
0x4c, 0x57, 0x0f, 0x31, 0xa5, 0xea, 0xa9, 0xb9, 0xd3, 0x8d, 0x03, 0x81, 0x50, 0x16, 0x22, 0x71},
nullptr,
},
{
// sha256(libVDSO:clock_getres)
{0xe4, 0xa1, 0xf6, 0x23, 0x35, 0xae, 0xb7, 0xb6, 0xb0, 0x37, 0xc5, 0xc3, 0xa3, 0xfd, 0xbf, 0xa2,
0xa1, 0xc8, 0x95, 0x78, 0xe5, 0x76, 0x86, 0xdb, 0x3e, 0x6c, 0x54, 0xd5, 0x02, 0x60, 0xd8, 0x6d},
nullptr,
},
{
// sha256(libVDSO:getcpu)
{0x39, 0x83, 0x39, 0x36, 0x0f, 0x68, 0xd6, 0xfc, 0xc2, 0x3a, 0x97, 0x11, 0x85, 0x09, 0xc7, 0x25,
0xbb, 0x50, 0x49, 0x55, 0x6b, 0x0c, 0x9f, 0x50, 0x37, 0xf5, 0x9d, 0xb0, 0x38, 0x58, 0x57, 0x12},
nullptr,
},
{
// sha256(libVDSO:getrandom)
{0xf8, 0x03, 0xe2, 0x70, 0xe3, 0xf1, 0xbb, 0xc1, 0x7d, 0xa7, 0x8b, 0xb3, 0x1f, 0x3e, 0xbd, 0xc6,
0x8a, 0x50, 0xd3, 0x4a, 0x1f, 0xb3, 0x4b, 0x7e, 0x32, 0xcb, 0x1e, 0x18, 0x3b, 0x7c, 0xeb, 0x4b},
nullptr,
},
}};
template<bool Is64Bit>
void LoadGuestVDSOSymbols(char* VDSOBase) {
using ELFHeaderType = std::conditional_t<Is64Bit, Elf64_Ehdr, Elf32_Ehdr>;
using ELFSHeaderType = std::conditional_t<Is64Bit, Elf64_Shdr, Elf32_Shdr>;
using ELFSymbolType = std::conditional_t<Is64Bit, Elf64_Sym, Elf32_Sym>;
constexpr auto ELFClass = Is64Bit ? ELFCLASS64 : ELFCLASS32;
constexpr auto ELFMachine = Is64Bit ? EM_X86_64 : EM_386;
// We need to load symbols we care about.
auto Header = reinterpret_cast<const ELFHeaderType*>(VDSOBase);
// Check ELF magic.
if (Header->e_ident[EI_MAG0] != ELFMAG0 || Header->e_ident[EI_MAG1] != ELFMAG1 || Header->e_ident[EI_MAG2] != ELFMAG2 ||
Header->e_ident[EI_MAG3] != ELFMAG3) {
return;
}
// Check ELF class and Machine.
if (Header->e_ident[EI_CLASS] != ELFClass || Header->e_machine != ELFMachine) {
return;
}
// First walk the section headers to find the symbol table.
auto RawShdrs = reinterpret_cast<const ELFSHeaderType*>(VDSOBase + Header->e_shoff);
const auto StrHeader = &RawShdrs[Header->e_shstrndx];
const char* SHStrings = VDSOBase + StrHeader->sh_offset;
struct SymbolTypes {
const char* name;
int sh_type;
};
constexpr std::array<SymbolTypes, 2> symbol_table_names = {{{".dynsym", SHT_DYNSYM}, {".symtab", SHT_SYMTAB}}};
for (auto sym_table : symbol_table_names) {
const ELFSHeaderType* SymTableHeader {};
const ELFSHeaderType* StringTableHeader {};
for (size_t i = 0; i < Header->e_shnum; ++i) {
const auto& Header = RawShdrs[i];
if (Header.sh_type == sym_table.sh_type && strcmp(&SHStrings[Header.sh_name], sym_table.name) == 0) {
SymTableHeader = &Header;
StringTableHeader = &RawShdrs[SymTableHeader->sh_link];
break;
}
}
if (!SymTableHeader) {
// Couldn't find symbol table
continue;
}
const char* StrTab = VDSOBase + StringTableHeader->sh_offset;
size_t NumSymbols = SymTableHeader->sh_size / SymTableHeader->sh_entsize;
for (size_t i = 0; i < NumSymbols; ++i) {
uint64_t offset = SymTableHeader->sh_offset + i * SymTableHeader->sh_entsize;
auto Symbol = reinterpret_cast<const ELFSymbolType*>(VDSOBase + offset);
if (ELF32_ST_VISIBILITY(Symbol->st_other) != STV_HIDDEN && Symbol->st_value != 0) {
const char* Name = &StrTab[Symbol->st_name];
if (Name[0] != '\0') {
if (strcmp(Name, "__kernel_sigreturn") == 0) {
VDSOPointers.VDSO_kernel_sigreturn = VDSOBase + Symbol->st_value;
} else if (strcmp(Name, "__kernel_rt_sigreturn") == 0) {
VDSOPointers.VDSO_kernel_rt_sigreturn = VDSOBase + Symbol->st_value;
} else if (strcmp(Name, "__fex_callback_ret") == 0) {
VDSOPointers.VDSO_FEX_CallbackRET = VDSOBase + Symbol->st_value;
}
}
}
}
}
}
void LoadFEXGeneratedCode(FEXCore::Core::InternalThreadState* Thread, bool Is64Bit, VDSOMapping* Mapping, FEX::HLE::SyscallHandler* const Handler) {
if (VDSOPointers.VDSO_FEX_CallbackRET && (!Is64Bit || (VDSOPointers.VDSO_kernel_sigreturn && VDSOPointers.VDSO_kernel_rt_sigreturn))) {
// Unnecessary if all VDSO paths have already been loaded.
return;
}
// Hardcoded to one page for now
auto PageSize = sysconf(_SC_PAGESIZE);
PageSize = PageSize > 0 ? PageSize : FEXCore::Utils::FEX_PAGE_SIZE;
Mapping->X86GeneratedCodeSize = PageSize;
if (Is64Bit) {
// 64bit mode can have its code anywhere
auto Result =
Handler->GuestMmap(Is64Bit, Thread, nullptr, Mapping->X86GeneratedCodeSize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (!FEX::HLE::HasSyscallError(Result)) {
Mapping->X86GeneratedCodePtr = Result;
}
} else {
// We need to have the sigret handler in the lower 32bits of memory space
// Scan top down and try to allocate a location
for (size_t Location = 0xFFFF'E000; Location != 0x0; Location -= PageSize) {
auto Ptr = Handler->GuestMmap(Is64Bit, Thread, reinterpret_cast<void*>(Location), PageSize, PROT_READ | PROT_WRITE,
MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (!FEX::HLE::HasSyscallError(Ptr)) {
Mapping->X86GeneratedCodePtr = Ptr;
break;
}
}
}
// Can't do anything about this
// Here's hoping the application doesn't use signals
if (!Mapping->X86GeneratedCodePtr) {
return;
}
FEXCore::Allocator::VirtualName("FEXMem_Misc", Mapping->X86GeneratedCodePtr, Mapping->X86GeneratedCodeSize);
size_t CurrentCodeOffset {};
if (!Is64Bit) {
// Signal return handlers need to be bit-exact to what the Linux kernel provides in VDSO.
// GDB and unwinding libraries key off of these instructions to understand if the stack frame is a signal frame or not.
// This two code sections match exactly what libSegFault expects.
//
// Typically this handlers are provided by the 32-bit VDSO thunk library, but that isn't available in all cases.
// Falling back to this generated code segment still allows a backtrace to work, just might not show
// the symbol as VDSO since there is no ELF to parse.
constexpr std::array<uint8_t, 9> sigreturn_32_code = {
0x58, // pop eax
0xb8, 0x77, 0x00, 0x00, 0x00, // mov eax, 0x77
0xcd, 0x80, // int 0x80
0x90, // nop
};
constexpr std::array<uint8_t, 7> rt_sigreturn_32_code = {
0xb8, 0xad, 0x00, 0x00, 0x00, // mov eax, 0xad
0xcd, 0x80, // int 0x80
};
if (!VDSOPointers.VDSO_kernel_sigreturn) {
VDSOPointers.VDSO_kernel_sigreturn = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(Mapping->X86GeneratedCodePtr) + CurrentCodeOffset);
memcpy(VDSOPointers.VDSO_kernel_sigreturn, sigreturn_32_code.data(), sigreturn_32_code.size());
CurrentCodeOffset += sigreturn_32_code.size();
}
if (!VDSOPointers.VDSO_kernel_rt_sigreturn) {
VDSOPointers.VDSO_kernel_rt_sigreturn =
reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(Mapping->X86GeneratedCodePtr) + CurrentCodeOffset);
memcpy(VDSOPointers.VDSO_kernel_rt_sigreturn, rt_sigreturn_32_code.data(), rt_sigreturn_32_code.size());
CurrentCodeOffset += rt_sigreturn_32_code.size();
}
}
if (!VDSOPointers.VDSO_FEX_CallbackRET) {
constexpr std::array<uint8_t, 2> CallbackRetCode = {
0x0F, 0x3E, // CALLBACKRET FEX Instruction
};
VDSOPointers.VDSO_FEX_CallbackRET = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(Mapping->X86GeneratedCodePtr) + CurrentCodeOffset);
memcpy(VDSOPointers.VDSO_FEX_CallbackRET, CallbackRetCode.data(), CallbackRetCode.size());
CurrentCodeOffset += CallbackRetCode.size();
}
Handler->GuestMprotect(Thread, Mapping->X86GeneratedCodePtr, Mapping->X86GeneratedCodeSize, PROT_READ | PROT_EXEC);
}
void UnloadVDSOMapping(FEXCore::Core::InternalThreadState* Thread, FEX::HLE::SyscallHandler* const Handler, const VDSOMapping& Mapping) {
if (Mapping.VDSOBase) {
Handler->GuestMunmap(Thread, Mapping.VDSOBase, Mapping.VDSOSize);
}
if (Mapping.X86GeneratedCodePtr) {
Handler->GuestMunmap(Thread, Mapping.X86GeneratedCodePtr, Mapping.X86GeneratedCodeSize);
}
}
VDSOMapping LoadVDSOThunks(FEXCore::Core::InternalThreadState* Thread, bool Is64Bit, FEX::HLE::SyscallHandler* const Handler) {
VDSOMapping Mapping {};
FEX_CONFIG_OPT(ThunkGuestLibs, THUNKGUESTLIBS);
fextl::string ThunkGuestPath = ThunkGuestLibs();
while (ThunkGuestPath.ends_with('/')) {
ThunkGuestPath.pop_back();
}
ThunkGuestPath = fextl::fmt::format("{}{}/libVDSO-guest.so", ThunkGuestPath, Is64Bit ? "" : "_32");
// Load VDSO if we can
int VDSOFD = ::open(ThunkGuestPath.c_str(), O_RDONLY);
if (VDSOFD != -1) {
// Get file size
Mapping.VDSOSize = lseek(VDSOFD, 0, SEEK_END);
if (Mapping.VDSOSize >= std::min(sizeof(Elf32_Ehdr), sizeof(Elf64_Ehdr))) {
// Reset to beginning
lseek(VDSOFD, 0, SEEK_SET);
Mapping.VDSOSize = FEXCore::AlignUp(Mapping.VDSOSize, FEXCore::Utils::FEX_PAGE_SIZE);
auto VABits = FEXCore::Allocator::GetHostVABits();
uint64_t VDSOHint {};
if (Is64Bit) {
if (VABits > 47) {
// If VA size is at least as large as minimum x86 specification, then set to max.
VABits = 47;
}
// Calculate the highest point the vdso could go.
VDSOHint = (1ULL << VABits) - Mapping.VDSOSize;
} else {
VDSOHint = 0x1'0000'0000ULL - Mapping.VDSOSize;
}
auto PageSize = sysconf(_SC_PAGESIZE);
PageSize = PageSize > 0 ? PageSize : FEXCore::Utils::FEX_PAGE_SIZE;
// Scan top down and try to allocate a location
void* VDSOPointerBase {};
do {
VDSOPointerBase = Handler->GuestMmap(Is64Bit, Thread, reinterpret_cast<void*>(VDSOHint), Mapping.VDSOSize, PROT_READ | PROT_EXEC,
MAP_FIXED_NOREPLACE | MAP_SHARED, VDSOFD, 0);
// Scan-downward until we fit.
VDSOHint -= PageSize;
} while (FEX::HLE::HasSyscallError(VDSOPointerBase) && static_cast<int64_t>(VDSOHint) > 0);
if (FEX::HLE::HasSyscallError(VDSOPointerBase)) {
LogMan::Msg::EFmt("Couldn't Map VDSO");
close(VDSOFD);
return {};
}
Mapping.VDSOBase = VDSOPointerBase;
// Since we found our VDSO thunk library, find our host VDSO function implementations.
LoadHostVDSO();
}
close(VDSOFD);
if (!Mapping.VDSOBase) {
return {};
}
if (Is64Bit) {
LoadGuestVDSOSymbols<true>(reinterpret_cast<char*>(Mapping.VDSOBase));
} else {
LoadGuestVDSOSymbols<false>(reinterpret_cast<char*>(Mapping.VDSOBase));
}
}
// If VDSO couldn't find sigreturn then FEX needs to provide unique implementations.
LoadFEXGeneratedCode(Thread, Is64Bit, &Mapping, Handler);
if (Is64Bit) {
// Set the Thunk definition pointers for x86-64
VDSODefinitions[0].ThunkFunction = FEX::VDSO::x64::Handler_time;
VDSODefinitions[1].ThunkFunction = FEX::VDSO::x64::Handler_gettimeofday;
VDSODefinitions[2].ThunkFunction = FEX::VDSO::x64::Handler_clock_gettime;
VDSODefinitions[3].ThunkFunction = FEX::VDSO::x64::Handler_clock_gettime;
VDSODefinitions[4].ThunkFunction = FEX::VDSO::x64::Handler_clock_getres;
VDSODefinitions[5].ThunkFunction = FEX::VDSO::x64::Handler_getcpu;
VDSODefinitions[6].ThunkFunction = FEX::VDSO::x64::Handler_getrandom;
} else {
// Set the Thunk definition pointers for x86
VDSODefinitions[0].ThunkFunction = FEX::VDSO::x32::Handler_time;
VDSODefinitions[1].ThunkFunction = FEX::VDSO::x32::Handler_gettimeofday;
VDSODefinitions[2].ThunkFunction = FEX::VDSO::x32::Handler_clock_gettime;
VDSODefinitions[3].ThunkFunction = FEX::VDSO::x32::Handler_clock_gettime64;
VDSODefinitions[4].ThunkFunction = FEX::VDSO::x32::Handler_clock_getres;
VDSODefinitions[5].ThunkFunction = FEX::VDSO::x32::Handler_getcpu;
// getrandom doesn't exist on 32-bit, so leave VDSODefinitions[6] unfilled
}
return Mapping;
}
uint64_t GetVSyscallEntry(const void* VDSOBase) {
if (!VDSOBase) {
return 0;
}
// Extract the vsyscall location from the VDSO header.
auto Header = reinterpret_cast<const Elf32_Ehdr*>(VDSOBase);
if (Header->e_entry) {
return reinterpret_cast<uint64_t>(VDSOBase) + Header->e_entry;
}
return 0;
}
const std::span<FEXCore::IR::ThunkDefinition> GetVDSOThunkDefinitions(bool Is64Bit) {
return std::span(VDSODefinitions.begin(), VDSODefinitions.end() - (Is64Bit ? 0 : 1));
}
const VDSOEntrypoints& GetVDSOSymbols() {
return VDSOPointers;
}
} // namespace FEX::VDSO
Reference in new issue View Git Blame Copy Permalink