steam-frame/FEX-Emu--FEX
1
0 Fork 0
mirror of https://github.com/FEX-Emu/FEX.git synced 2026-10-06 13:00:15 +02:00
Code Issues Packages Projects Releases 66 Wiki Activity

Resolve comments.

Browse Source
This commit is contained in:
Ryan Houdek committed 2022-02-28 21:04:03 -08:00
1 parent 3e9dbda146
commit a0efd2b01f
62 files changed
+1363 -291
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

External/FEXCore/Source/Interface/Core/ArchHelpers/Arm64Emitter.h
Vendored
+1 -6
View File
@@ -65,12 +65,7 @@ protected:
void SpillStaticRegs(bool FPRs = true, uint32_t GPRSpillMask = ~0U, uint32_t FPRSpillMask = ~0U);
void FillStaticRegs(bool FPRs = true, uint32_t GPRFillMask = ~0U, uint32_t FPRFillMask = ~0U);
static constexpr uint32_t CALLER_GPR_MASK =
(1U << 0) | (1U << 1) | (1U << 2) | (1U << 3) |
(1U << 4) | (1U << 5) | (1U << 6) | (1U << 7) |
(1U << 8) | (1U << 9) | (1U << 10) | (1U << 11) |
(1U << 12) | (1U << 13) | (1U << 14) | (1U << 15) |
(1U << 16) | (1U << 17) | (1U << 18);
static constexpr uint32_t CALLER_GPR_MASK = 0b0011'1111'1111'1111'1111;
// This isn't technically true because the lower 64-bits of v8..v15 are callee saved
// We can't guarantee only the lower 64bits are used so flush everything
External/FEXCore/Source/Interface/Core/JIT/Arm64/BranchOps.cpp
Vendored
+6 -8
View File
@@ -185,10 +185,10 @@ DEF_OP(Syscall) {
// X1: ThreadState
// X2: Pointer to SyscallArguments
uint8_t Flags = Op->Flags;
FEXCore::IR::SyscallFlags Flags = Op->Flags;
PushDynamicRegsAndLR();
if ((Flags & FEXCore::IR::SYSCALL_FLAG_NOSYNCSTATEONENTRY) != FEXCore::IR::SYSCALL_FLAG_NOSYNCSTATEONENTRY) {
if ((Flags & FEXCore::IR::SyscallFlags::NOSYNCSTATEONENTRY) != FEXCore::IR::SyscallFlags::NOSYNCSTATEONENTRY) {
SpillStaticRegs();
}
else {
@@ -211,8 +211,8 @@ DEF_OP(Syscall) {
add(sp, sp, SPOffset);
if ((Flags & FEXCore::IR::SYSCALL_FLAG_NOSYNCSTATEONENTRY) != FEXCore::IR::SYSCALL_FLAG_NOSYNCSTATEONENTRY &&
(Flags & FEXCore::IR::SYSCALL_FLAG_NORETURN) != FEXCore::IR::SYSCALL_FLAG_NORETURN) {
if ((Flags & FEXCore::IR::SyscallFlags::NOSYNCSTATEONENTRY) != FEXCore::IR::SyscallFlags::NOSYNCSTATEONENTRY &&
(Flags & FEXCore::IR::SyscallFlags::NORETURN) != FEXCore::IR::SyscallFlags::NORETURN) {
FillStaticRegs();
}
else {
@@ -223,7 +223,7 @@ DEF_OP(Syscall) {
PopDynamicRegsAndLR();
if ((Flags & FEXCore::IR::SYSCALL_FLAG_NORETURN) != FEXCore::IR::SYSCALL_FLAG_NORETURN) {
if ((Flags & FEXCore::IR::SyscallFlags::NORETURN) != FEXCore::IR::SyscallFlags::NORETURN) {
// Move result to its destination register
mov(GetReg<RA_64>(Node), x0);
}
@@ -357,13 +357,11 @@ DEF_OP(InlineSyscall) {
svc(0);
// On updated signal mask we can receive a signal RIGHT HERE
if ((Op->Flags & FEXCore::IR::SYSCALL_FLAG_NORETURN) != FEXCore::IR::SYSCALL_FLAG_NORETURN) {
if ((Op->Flags & FEXCore::IR::SyscallFlags::NORETURN) != FEXCore::IR::SyscallFlags::NORETURN) {
// Now that we are done in the syscall we need to carefully peel back the state
// First unspill the registers from before
FillStaticRegs(false, SpillMask);
}
if ((Op->Flags & FEXCore::IR::SYSCALL_FLAG_NORETURN) == 0) {
// Now the registers we've spilled are back in their original host registers
// We can safely claim we are no longer in a syscall
str(xzr, MemOperand(STATE, offsetof(FEXCore::Core::CpuStateFrame, InSyscallInfo)));
External/FEXCore/Source/Interface/Core/OpcodeDispatcher.cpp
Vendored
+1 -1
View File
@@ -108,7 +108,7 @@ void OpDispatchBuilder::SyscallOp(OpcodeArgs) {
Arguments[4],
Arguments[5],
Arguments[6],
FEXCore::IR::SYSCALL_FLAG_DEFAULT);
FEXCore::IR::SyscallFlags::DEFAULT);
if (OSABI != FEXCore::HLE::SyscallOSABI::OS_HANGOVER) {
// Hangover doesn't want us returning a result here
External/FEXCore/Source/Interface/IR/IR.json
Vendored
+3 -9
View File
@@ -75,13 +75,7 @@
"constexpr FEXCore::IR::BreakReason Break_Interrupt3 {2}",
"constexpr FEXCore::IR::BreakReason Break_Halt {3}",
"constexpr FEXCore::IR::BreakReason Break_Overflow {4}",
"constexpr FEXCore::IR::BreakReason Break_InvalidInstruction {5}",
"constexpr uint8_t SYSCALL_FLAG_DEFAULT {0}",
"constexpr uint8_t SYSCALL_FLAG_OPTIMIZETHROUGH {1 << 0}",
"constexpr uint8_t SYSCALL_FLAG_NOSYNCSTATEONENTRY {1 << 1}",
"constexpr uint8_t SYSCALL_FLAG_NORETURN {1 << 2}",
"constexpr uint8_t SYSCALL_FLAG_NOSIDEEFFECTS {1 << 3}"
"constexpr FEXCore::IR::BreakReason Break_InvalidInstruction {5}"
],
"Ops": {
@@ -707,7 +701,7 @@
"Arg5"
],
"Args": [
"uint8_t", "Flags"
"FEXCore::IR::SyscallFlags", "Flags"
]
},
@@ -735,7 +729,7 @@
],
"Args": [
"int32_t", "HostSyscallNumber",
"uint8_t", "Flags"
"FEXCore::IR::SyscallFlags", "Flags"
]
},
External/FEXCore/Source/Interface/IR/IRDumper.cpp
Vendored
+13
View File
@@ -171,6 +171,19 @@ static void PrintArg(std::stringstream *out, [[maybe_unused]] IRListView const*
}
}
static void PrintArg(std::stringstream *out, [[maybe_unused]] IRListView const* IR, FEXCore::IR::SyscallFlags Arg) {
switch (Arg) {
case FEXCore::IR::SyscallFlags::DEFAULT: *out << "Default"; break;
case FEXCore::IR::SyscallFlags::OPTIMIZETHROUGH: *out << "Optimize Through"; break;
case FEXCore::IR::SyscallFlags::NOSYNCSTATEONENTRY: *out << "No Sync State on Entry"; break;
case FEXCore::IR::SyscallFlags::NORETURN: *out << "No Return"; break;
case FEXCore::IR::SyscallFlags::NOSIDEEFFECTS: *out << "No Side Effects"; break;
default: *out << "<Unknown Round Type>"; break;
}
}
void Dump(std::stringstream *out, IRListView const* IR, IR::RegisterAllocationData *RAData) {
auto HeaderOp = IR->GetHeader();
External/FEXCore/Source/Interface/IR/Passes/DeadCodeElimination.cpp
Vendored
+2 -2
View File
@@ -40,7 +40,7 @@ bool DeadCodeElimination::Run(IREmitter *IREmit) {
bool HasSideEffects = IR::HasSideEffects(IROp->Op);
if (IROp->Op == OP_SYSCALL ||
IROp->Op == OP_INLINESYSCALL) {
uint32_t Flags{};
FEXCore::IR::SyscallFlags Flags{};
if (IROp->Op == OP_SYSCALL) {
auto Op = IROp->C<IR::IROp_Syscall>();
Flags = Op->Flags;
@@ -50,7 +50,7 @@ bool DeadCodeElimination::Run(IREmitter *IREmit) {
Flags = Op->Flags;
}
if (Flags & FEXCore::IR::SYSCALL_FLAG_NOSIDEEFFECTS) {
if ((Flags & FEXCore::IR::SyscallFlags::NOSIDEEFFECTS) == FEXCore::IR::SyscallFlags::NOSIDEEFFECTS) {
HasSideEffects = false;
}
}
External/FEXCore/Source/Interface/IR/Passes/DeadContextStoreElimination.cpp
Vendored
+2 -2
View File
@@ -663,7 +663,7 @@ bool RCLSE::RedundantStoreLoadElimination(FEXCore::IR::IREmitter *IREmit) {
}
else if (IROp->Op == OP_SYSCALL ||
IROp->Op == OP_INLINESYSCALL) {
uint32_t Flags{};
FEXCore::IR::SyscallFlags Flags{};
if (IROp->Op == OP_SYSCALL) {
auto Op = IROp->C<IR::IROp_Syscall>();
Flags = Op->Flags;
@@ -673,7 +673,7 @@ bool RCLSE::RedundantStoreLoadElimination(FEXCore::IR::IREmitter *IREmit) {
Flags = Op->Flags;
}
if ((Flags & FEXCore::IR::SYSCALL_FLAG_OPTIMIZETHROUGH) != FEXCore::IR::SYSCALL_FLAG_OPTIMIZETHROUGH) {
if ((Flags & FEXCore::IR::SyscallFlags::OPTIMIZETHROUGH) != FEXCore::IR::SyscallFlags::OPTIMIZETHROUGH) {
// We can't track through these
ResetClassificationAccesses(&LocalInfo);
}
External/FEXCore/include/FEXCore/HLE/SyscallHandler.h
Vendored
+3 -1
View File
@@ -2,6 +2,8 @@
#include <cstdint>
#include <string>
#include <FEXCore/IR/IR.h>
namespace FEXCore::Context {
struct Context;
}
@@ -43,7 +45,7 @@ namespace FEXCore::HLE {
virtual uint64_t HandleSyscall(FEXCore::Core::CpuStateFrame *Frame, FEXCore::HLE::SyscallArguments *Args) = 0;
virtual SyscallABI GetSyscallABI(uint64_t Syscall) = 0;
virtual uint32_t GetSyscallFlags(uint64_t Syscall) const { return 0; }
virtual FEXCore::IR::SyscallFlags GetSyscallFlags(uint64_t Syscall) const { return FEXCore::IR::SyscallFlags::DEFAULT; }
SyscallOSABI GetOSABI() const { return OSABI; }
External/FEXCore/include/FEXCore/IR/IR.h
Vendored
+11
View File
@@ -1,6 +1,7 @@
#pragma once
#include <FEXCore/Utils/CompilerDefs.h>
#include <FEXHeaderUtils/EnumOperators.h>
#include <array>
#include <cassert>
@@ -482,6 +483,16 @@ protected:
OrderedNodeWrapper Node{};
};
enum class SyscallFlags : uint8_t {
DEFAULT = 0,
OPTIMIZETHROUGH = 1 << 0,
NOSYNCSTATEONENTRY = 1 << 1,
NORETURN = 1 << 2,
NOSIDEEFFECTS = 1 << 3
};
FEX_DEF_NUM_OPS(SyscallFlags)
#define IROP_ENUM
#define IROP_STRUCTS
#define IROP_SIZES
FEXHeaderUtils/FEXHeaderUtils/EnumOperators.h
+24
View File
@@ -0,0 +1,24 @@
#pragma once
#define FEX_DEF_ENUM_CLASS_BIN_OP(Enum, Op) \
[[maybe_unused]] \
static constexpr Enum operator Op(Enum lhs, Enum rhs) { \
using Type = std::underlying_type_t<Enum>; \
Type _lhs = static_cast<Type>(lhs); \
Type _rhs = static_cast<Type>(rhs); \
return static_cast<Enum>(_lhs Op _rhs); \
}
#define FEX_DEF_ENUM_CLASS_UNARY_OP(Enum, Op) \
[[maybe_unused]] \
static constexpr Enum operator Op(Enum rhs) { \
using Type = std::underlying_type_t<Enum>; \
Type _rhs = static_cast<Type>(rhs); \
return static_cast<Enum>(Op _rhs); \
}
#define FEX_DEF_NUM_OPS(Enum) \
FEX_DEF_ENUM_CLASS_BIN_OP(Enum, |) \
FEX_DEF_ENUM_CLASS_BIN_OP(Enum, &) \
FEX_DEF_ENUM_CLASS_BIN_OP(Enum, ^) \
FEX_DEF_ENUM_CLASS_UNARY_OP(Enum, ~)
Source/Tests/LinuxSyscalls/Syscalls.h
+6 -6
View File
@@ -99,7 +99,7 @@ public:
struct SyscallFunctionDefinition {
uint8_t NumArgs;
uint8_t Flags;
FEXCore::IR::SyscallFlags Flags;
union {
void* Ptr;
SyscallPtrArg0 Ptr0;
@@ -125,7 +125,7 @@ public:
return {Def.NumArgs, true, Def.HostSyscallNumber};
}
uint32_t GetSyscallFlags(uint64_t Syscall) const override {
FEXCore::IR::SyscallFlags GetSyscallFlags(uint64_t Syscall) const override {
auto &Def = Definitions.at(Syscall);
return Def.Flags;
}
@@ -395,8 +395,8 @@ static bool HasSyscallError(const void* Result) {
struct impl_##name { \
impl_##name() \
{ \
FEX::HLE::x64::RegisterSyscall(FEX::HLE::x64::SYSCALL_x64_##name, ~0, FEXCore::IR::SYSCALL_FLAG_DEFAULT, #name, lambda); \
FEX::HLE::x32::RegisterSyscall(FEX::HLE::x32::SYSCALL_x86_##name, ~0, FEXCore::IR::SYSCALL_FLAG_DEFAULT, #name, lambda); \
FEX::HLE::x64::RegisterSyscall(FEX::HLE::x64::SYSCALL_x64_##name, ~0, FEXCore::IR::SyscallFlags::DEFAULT, #name, lambda); \
FEX::HLE::x32::RegisterSyscall(FEX::HLE::x32::SYSCALL_x86_##name, ~0, FEXCore::IR::SyscallFlags::DEFAULT, #name, lambda); \
} } impl_##name
// Registers syscall for both 32bit and 64bit
@@ -404,8 +404,8 @@ static bool HasSyscallError(const void* Result) {
struct impl_##name { \
impl_##name() \
{ \
FEX::HLE::x64::RegisterSyscall(FEX::HLE::x64::SYSCALL_x64_##name, SYSCALL_DEF(name), FEXCore::IR::SYSCALL_FLAG_DEFAULT, #name, lambda); \
FEX::HLE::x32::RegisterSyscall(FEX::HLE::x32::SYSCALL_x86_##name, SYSCALL_DEF(name), FEXCore::IR::SYSCALL_FLAG_DEFAULT, #name, lambda); \
FEX::HLE::x64::RegisterSyscall(FEX::HLE::x64::SYSCALL_x64_##name, SYSCALL_DEF(name), FEXCore::IR::SyscallFlags::DEFAULT, #name, lambda); \
FEX::HLE::x32::RegisterSyscall(FEX::HLE::x32::SYSCALL_x86_##name, SYSCALL_DEF(name), FEXCore::IR::SyscallFlags::DEFAULT, #name, lambda); \
} } impl_##name
#define REGISTER_SYSCALL_IMPL_FLAGS(name, flags, lambda) \
Source/Tests/LinuxSyscalls/Syscalls/EPoll.cpp
+2 -2
View File
@@ -18,13 +18,13 @@ namespace FEX::HLE {
void RegisterEpoll() {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_PASS_FLAGS(epoll_create, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(epoll_create, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int size) -> uint64_t {
uint64_t Result = epoll_create(size);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(epoll_create1, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(epoll_create1, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int flags) -> uint64_t {
uint64_t Result = epoll_create1(flags);
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/Syscalls/FD.cpp
+54 -54
View File
@@ -31,193 +31,193 @@ namespace FEX::HLE {
void RegisterFD(FEX::HLE::SyscallHandler *const Handler) {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_PASS_FLAGS(read, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(read, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, void *buf, size_t count) -> uint64_t {
uint64_t Result = ::read(fd, buf, count);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(write, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(write, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, void *buf, size_t count) -> uint64_t {
uint64_t Result = ::write(fd, buf, count);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(open, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(open, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, int flags, uint32_t mode) -> uint64_t {
flags = FEX::HLE::RemapFromX86Flags(flags);
uint64_t Result = FEX::HLE::_SyscallHandler->FM.Open(pathname, flags, mode);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(close, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(close, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd) -> uint64_t {
uint64_t Result = FEX::HLE::_SyscallHandler->FM.Close(fd);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(chown, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(chown, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, uid_t owner, gid_t group) -> uint64_t {
uint64_t Result = ::chown(pathname, owner, group);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchown, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchown, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, uid_t owner, gid_t group) -> uint64_t {
uint64_t Result = ::fchown(fd, owner, group);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(lchown, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(lchown, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, uid_t owner, gid_t group) -> uint64_t {
uint64_t Result = ::lchown(pathname, owner, group);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(lseek, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(lseek, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, uint64_t offset, int whence) -> uint64_t {
uint64_t Result = ::lseek(fd, offset, whence);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(access, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(access, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, int mode) -> uint64_t {
uint64_t Result = FEX::HLE::_SyscallHandler->FM.Access(pathname, mode);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pipe, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pipe, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int pipefd[2]) -> uint64_t {
uint64_t Result = ::pipe(pipefd);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(dup3, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(dup3, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame* Frame, int oldfd, int newfd, int flags) -> uint64_t {
flags = FEX::HLE::RemapFromX86Flags(flags);
uint64_t Result = ::dup3(oldfd, newfd, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(flock, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(flock, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, int operation) -> uint64_t {
uint64_t Result = ::flock(fd, operation);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fsync, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fsync, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd) -> uint64_t {
uint64_t Result = ::fsync(fd);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fdatasync, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fdatasync, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd) -> uint64_t {
uint64_t Result = ::fdatasync(fd);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(ftruncate, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(ftruncate, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, off_t length) -> uint64_t {
uint64_t Result = ::ftruncate(fd, length);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchmod, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchmod, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, int mode) -> uint64_t {
uint64_t Result = ::fchmod(fd, mode);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fadvise64, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fadvise64, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, off_t offset, off_t len, int advice) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(fadvise64), fd, offset, len, advice);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(inotify_init, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(inotify_init, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
uint64_t Result = ::inotify_init();
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(inotify_add_watch, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(inotify_add_watch, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, const char *pathname, uint32_t mask) -> uint64_t {
uint64_t Result = ::inotify_add_watch(fd, pathname, mask);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(inotify_rm_watch, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(inotify_rm_watch, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, int wd) -> uint64_t {
uint64_t Result = ::inotify_rm_watch(fd, wd);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(openat, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(openat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dirfs, const char *pathname, int flags, uint32_t mode) -> uint64_t {
flags = FEX::HLE::RemapFromX86Flags(flags);
uint64_t Result = FEX::HLE::_SyscallHandler->FM.Openat(dirfs, pathname, flags, mode);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mkdirat, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mkdirat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, mode_t mode) -> uint64_t {
uint64_t Result = ::mkdirat(dirfd, pathname, mode);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mknodat, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mknodat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, mode_t mode, dev_t dev) -> uint64_t {
uint64_t Result = ::mknodat(dirfd, pathname, mode, dev);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchownat, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchownat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, uid_t owner, gid_t group, int flags) -> uint64_t {
// Flags don't need remapped
uint64_t Result = ::fchownat(dirfd, pathname, owner, group, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(unlinkat, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(unlinkat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, int flags) -> uint64_t {
// Flags don't need remapped
uint64_t Result = ::unlinkat(dirfd, pathname, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(renameat, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(renameat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int olddirfd, const char *oldpath, int newdirfd, const char *newpath) -> uint64_t {
uint64_t Result = ::renameat(olddirfd, oldpath, newdirfd, newpath);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(linkat, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(linkat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags) -> uint64_t {
// Flags don't need remapped
uint64_t Result = ::linkat(olddirfd, oldpath, newdirfd, newpath, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(symlinkat, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(symlinkat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *target, int newdirfd, const char *linkpath) -> uint64_t {
uint64_t Result = ::symlinkat(target, newdirfd, linkpath);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(readlinkat, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(readlinkat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, char *buf, size_t bufsiz) -> uint64_t {
uint64_t Result = FEX::HLE::_SyscallHandler->FM.Readlinkat(dirfd, pathname, buf, bufsiz);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchmodat, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchmodat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, mode_t mode) -> uint64_t {
uint64_t Result = syscall(SYSCALL_DEF(fchmodat), dirfd, pathname, mode);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(faccessat, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(faccessat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, int mode) -> uint64_t {
uint64_t Result = FEX::HLE::_SyscallHandler->FM.FAccessat(dirfd, pathname, mode);
SYSCALL_ERRNO();
@@ -225,19 +225,19 @@ namespace FEX::HLE {
if (Handler->IsHostKernelVersionAtLeast(5, 8, 0)) {
// Only exists on kernel 5.8+
REGISTER_SYSCALL_IMPL_FLAGS(faccessat2, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(faccessat2, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, int mode, int flags) -> uint64_t {
uint64_t Result = FEX::HLE::_SyscallHandler->FM.FAccessat2(dirfd, pathname, mode, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pidfd_getfd, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pidfd_getfd, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int pidfd, int fd, unsigned int flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(pidfd_getfd), pidfd, fd, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(openat2, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(openat2, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dirfs, const char *pathname, struct open_how *how, size_t usize) -> uint64_t {
open_how HostHow{};
size_t HostSize = std::min(sizeof(open_how), usize);
@@ -254,90 +254,90 @@ namespace FEX::HLE {
REGISTER_SYSCALL_IMPL(openat2, UnimplementedSyscallSafe);
}
REGISTER_SYSCALL_IMPL_PASS_FLAGS(splice, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(splice, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags) -> uint64_t {
// Flags don't need remapped
uint64_t Result = ::splice(fd_in, off_in, fd_out, off_out, len, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(tee, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(tee, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd_in, int fd_out, size_t len, unsigned int flags) -> uint64_t {
// Flags don't need remapped
uint64_t Result = ::tee(fd_in, fd_out, len, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(timerfd_create, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(timerfd_create, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int32_t clockid, int32_t flags) -> uint64_t {
// Flags don't need remapped
uint64_t Result = ::timerfd_create(clockid, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(eventfd, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(eventfd, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, uint32_t count) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(eventfd2), count, 0);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(pipe2, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(pipe2, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int pipefd[2], int flags) -> uint64_t {
flags = FEX::HLE::RemapFromX86Flags(flags);
uint64_t Result = ::pipe2(pipefd, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(inotify_init1, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(inotify_init1, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int flags) -> uint64_t {
// Flags don't need remapped
uint64_t Result = ::inotify_init1(flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(renameat2, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(renameat2, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int olddirfd, const char *oldpath, int newdirfd, const char *newpath, unsigned int flags) -> uint64_t {
// Flags don't need remapped
uint64_t Result = FHU::Syscalls::renameat2(olddirfd, oldpath, newdirfd, newpath, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(memfd_create, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(memfd_create, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *name, uint32_t flags) -> uint64_t {
// Flags don't need remapped
uint64_t Result = ::memfd_create(name, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(statx, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(statx, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, int flags, uint32_t mask, struct statx *statxbuf) -> uint64_t {
// Flags don't need remapped
uint64_t Result = FEX::HLE::_SyscallHandler->FM.Statx(dirfd, pathname, flags, mask, statxbuf);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(name_to_handle_at, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(name_to_handle_at, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, struct file_handle *handle, int *mount_id, int flags) -> uint64_t {
// Flags don't need remapped
uint64_t Result = ::name_to_handle_at(dirfd, pathname, handle, mount_id, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(open_by_handle_at, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(open_by_handle_at, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int mount_fd, struct file_handle *handle, int flags) -> uint64_t {
// Flags don't need remapped
uint64_t Result = ::open_by_handle_at(mount_fd, handle, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(eventfd2, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(eventfd2, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, unsigned int count, int flags) -> uint64_t {
// Flags don't need remapped
uint64_t Result = ::syscall(SYSCALL_DEF(eventfd2), count, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(copy_file_range, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(copy_file_range, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags) -> uint64_t {
// Flags don't need remapped
uint64_t Result = ::copy_file_range(fd_in, off_in, fd_out, off_out, len, flags);
@@ -345,7 +345,7 @@ namespace FEX::HLE {
});
if (Handler->IsHostKernelVersionAtLeast(5, 3, 0)) {
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pidfd_open, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pidfd_open, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, unsigned int flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(pidfd_open), pid, flags);
SYSCALL_ERRNO();
@@ -356,7 +356,7 @@ namespace FEX::HLE {
}
if (Handler->IsHostKernelVersionAtLeast(5, 9, 0)) {
REGISTER_SYSCALL_IMPL_FLAGS(close_range, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(close_range, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, unsigned int first, unsigned int last, unsigned int flags) -> uint64_t {
uint64_t Result = FEX::HLE::_SyscallHandler->FM.CloseRange(first, last, flags);
SYSCALL_ERRNO();
@@ -367,17 +367,17 @@ namespace FEX::HLE {
}
if (Handler->IsHostKernelVersionAtLeast(5, 13, 0)) {
REGISTER_SYSCALL_IMPL_PASS_FLAGS(landlock_create_ruleset, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(landlock_create_ruleset, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, void *const rule_attr, size_t size, uint32_t flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(landlock_create_ruleset), rule_attr, size, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(landlock_add_rule, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(landlock_add_rule, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, uint32_t ruleset_fd, uint64_t rule_type, void *const rule_attr, uint32_t flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(landlock_add_rule), ruleset_fd, rule_type, rule_attr, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(landlock_restrict_self, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(landlock_restrict_self, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, uint32_t ruleset_fd, uint32_t flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(landlock_restrict_self), ruleset_fd, flags);
SYSCALL_ERRNO();
@@ -390,7 +390,7 @@ namespace FEX::HLE {
}
if (Handler->IsHostKernelVersionAtLeast(5, 14, 0)) {
REGISTER_SYSCALL_IMPL_PASS_FLAGS(memfd_secret, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(memfd_secret, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, uint32_t flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(memfd_secret), flags);
SYSCALL_ERRNO();
@@ -401,7 +401,7 @@ namespace FEX::HLE {
}
if (Handler->IsHostKernelVersionAtLeast(5, 15, 0)) {
REGISTER_SYSCALL_IMPL_PASS_FLAGS(process_mrelease, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(process_mrelease, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int pidfd, uint32_t flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(process_mrelease), pidfd, flags);
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/Syscalls/FS.cpp
+41 -41
View File
@@ -25,85 +25,85 @@ namespace FEX::HLE {
void RegisterFS(FEX::HLE::SyscallHandler *const Handler) {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getcwd, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getcwd, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, char *buf, size_t size) -> uint64_t {
uint64_t Result = syscall(SYSCALL_DEF(getcwd), buf, size);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(chdir, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(chdir, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *path) -> uint64_t {
uint64_t Result = ::chdir(path);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchdir, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fchdir, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd) -> uint64_t {
uint64_t Result = ::fchdir(fd);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(rename, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(rename, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *oldpath, const char *newpath) -> uint64_t {
uint64_t Result = ::rename(oldpath, newpath);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mkdir, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mkdir, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, mode_t mode) -> uint64_t {
uint64_t Result = ::mkdir(pathname, mode);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(rmdir, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(rmdir, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *pathname) -> uint64_t {
uint64_t Result = ::rmdir(pathname);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(link, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(link, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *oldpath, const char *newpath) -> uint64_t {
uint64_t Result = ::link(oldpath, newpath);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(unlink, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(unlink, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *pathname) -> uint64_t {
uint64_t Result = ::unlink(pathname);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(symlink, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(symlink, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *target, const char *linkpath) -> uint64_t {
uint64_t Result = ::symlink(target, linkpath);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(readlink, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(readlink, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, char *buf, size_t bufsiz) -> uint64_t {
uint64_t Result = FEX::HLE::_SyscallHandler->FM.Readlink(pathname, buf, bufsiz);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(chmod, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(chmod, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, mode_t mode) -> uint64_t {
uint64_t Result = ::chmod(pathname, mode);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(umask, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(umask, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, mode_t mask) -> uint64_t {
uint64_t Result = ::umask(mask);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(mknod, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(mknod, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, mode_t mode, dev_t dev) -> uint64_t {
uint64_t Result = FEX::HLE::_SyscallHandler->FM.Mknod(pathname, mode, dev);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(ustat, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(ustat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, dev_t dev, struct ustat *ubuf) -> uint64_t {
// Doesn't exist on AArch64, will return -ENOSYS
// Since version 2.28 of GLIBC it has stopped providing a wrapper for this syscall
@@ -115,165 +115,165 @@ namespace FEX::HLE {
arg1 is one of: void, unsigned int fs_index, const char *fsname
arg2 is one of: void, char *buf
*/
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sysfs, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sysfs, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int option, uint64_t arg1, uint64_t arg2) -> uint64_t {
// Doesn't exist on AArch64, will return -ENOSYS
uint64_t Result = syscall(SYSCALL_DEF(sysfs), option, arg1, arg2);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(truncate, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(truncate, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *path, off_t length) -> uint64_t {
uint64_t Result = ::truncate(path, length);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(creat, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(creat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, mode_t mode) -> uint64_t {
uint64_t Result = ::creat(pathname, mode);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(chroot, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(chroot, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *path) -> uint64_t {
uint64_t Result = ::chroot(path);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sync, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sync, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
sync();
return 0; // always successful
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(acct, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(acct, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *filename) -> uint64_t {
uint64_t Result = ::acct(filename);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mount, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mount, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *source, const char *target, const char *filesystemtype, unsigned long mountflags, const void *data) -> uint64_t {
uint64_t Result = ::mount(source, target, filesystemtype, mountflags, data);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(umount2, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(umount2, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *target, int flags) -> uint64_t {
uint64_t Result = ::umount2(target, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(swapon, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(swapon, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *path, int swapflags) -> uint64_t {
uint64_t Result = ::swapon(path, swapflags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(swapoff, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(swapoff, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *path) -> uint64_t {
uint64_t Result = ::swapoff(path);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(syncfs, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(syncfs, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd) -> uint64_t {
uint64_t Result = ::syncfs(fd);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setxattr, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setxattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *path, const char *name, const void *value, size_t size, int flags) -> uint64_t {
uint64_t Result = ::setxattr(path, name, value, size, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(lsetxattr, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(lsetxattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *path, const char *name, const void *value, size_t size, int flags) -> uint64_t {
uint64_t Result = ::lsetxattr(path, name, value, size, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fsetxattr, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fsetxattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, const char *name, const void *value, size_t size, int flags) -> uint64_t {
uint64_t Result = ::fsetxattr(fd, name, value, size, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getxattr, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getxattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *path, const char *name, void *value, size_t size) -> uint64_t {
uint64_t Result = ::getxattr(path, name, value, size);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(lgetxattr, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(lgetxattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *path, const char *name, void *value, size_t size) -> uint64_t {
uint64_t Result = ::lgetxattr(path, name, value, size);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fgetxattr, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fgetxattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, const char *name, void *value, size_t size) -> uint64_t {
uint64_t Result = ::fgetxattr(fd, name, value, size);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(listxattr, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(listxattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *path, char *list, size_t size) -> uint64_t {
uint64_t Result = ::listxattr(path, list, size);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(llistxattr, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(llistxattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *path, char *list, size_t size) -> uint64_t {
uint64_t Result = ::llistxattr(path, list, size);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(flistxattr, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(flistxattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, char *list, size_t size) -> uint64_t {
uint64_t Result = ::flistxattr(fd, list, size);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(removexattr, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(removexattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *path, const char *name) -> uint64_t {
uint64_t Result = ::removexattr(path, name);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(lremovexattr, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(lremovexattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *path, const char *name) -> uint64_t {
uint64_t Result = ::lremovexattr(path, name);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fremovexattr, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fremovexattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, const char *name) -> uint64_t {
uint64_t Result = ::fremovexattr(fd, name);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fanotify_init, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fanotify_init, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, unsigned int flags, unsigned int event_f_flags) -> uint64_t {
uint64_t Result = ::fanotify_init(flags, event_f_flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fanotify_mark, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fanotify_mark, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fanotify_fd, unsigned int flags, uint64_t mask, int dirfd, const char *pathname) -> uint64_t {
uint64_t Result = ::fanotify_mark(fanotify_fd, flags, mask, dirfd, pathname);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pivot_root, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pivot_root, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *new_root, const char *put_old) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(pivot_root), new_root, put_old);
SYSCALL_ERRNO();
});
if (Handler->IsHostKernelVersionAtLeast(5, 14, 0)) {
REGISTER_SYSCALL_IMPL_PASS_FLAGS(quotactl_fd, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(quotactl_fd, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, uint32_t fd, uint32_t cmd, uint32_t id, void* addr) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(quotactl_fd), fd, cmd, id, addr);
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/Syscalls/IO.cpp
+8 -8
View File
@@ -18,49 +18,49 @@ namespace FEX::HLE {
void RegisterIO() {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_PASS_FLAGS(iopl, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(iopl, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int level) -> uint64_t {
// Just claim we don't have permission
return -EPERM;
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(ioperm, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(ioperm, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, unsigned long from, unsigned long num, int turn_on) -> uint64_t {
// ioperm not available on our architecture
return -EPERM;
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_setup, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_setup, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, unsigned nr_events, aio_context_t *ctx_idp) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(io_setup), nr_events, ctx_idp);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_destroy, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_destroy, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, aio_context_t ctx_id) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(io_destroy), ctx_id);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_submit, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_submit, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, aio_context_t ctx_id, long nr, struct iocb **iocbpp) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(io_submit), ctx_id, nr, iocbpp);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_cancel, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_cancel, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, aio_context_t ctx_id, struct iocb *iocb, struct io_event *result) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(io_cancel), ctx_id, iocb, result);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(ioprio_set, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(ioprio_set, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int which, int who) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(ioprio_set), which, who);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(ioprio_get, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(ioprio_get, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int which, int who, int ioprio) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(ioprio_get), which, who, ioprio);
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/Syscalls/IOUring.cpp
+3 -3
View File
@@ -25,19 +25,19 @@ namespace FEX::HLE {
using namespace FEXCore::IR;
if (Handler->IsHostKernelVersionAtLeast(5, 1, 0)) {
REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_uring_setup, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_uring_setup, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, uint32_t entries, void* params) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(io_uring_setup), entries, params);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_uring_enter, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_uring_enter, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, unsigned int fd, uint32_t to_submit, uint32_t min_complete, uint32_t flags, void *argp, size_t argsz) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(io_uring_enter), fd, to_submit, min_complete, flags, argp, argsz);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_uring_register, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(io_uring_register, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, unsigned int fd, unsigned int opcode, void *arg, uint32_t nr_args) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(io_uring_register), fd, opcode, arg, nr_args);
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/Syscalls/Info.cpp
+8 -8
View File
@@ -34,7 +34,7 @@ namespace FEX::HLE {
void RegisterInfo() {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_FLAGS(uname, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(uname, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, struct utsname *buf) -> uint64_t {
struct utsname Local{};
if (::uname(&Local) == 0) {
@@ -62,31 +62,31 @@ namespace FEX::HLE {
return 0;
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(syslog, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(syslog, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int type, char *bufp, int len) -> uint64_t {
uint64_t Result = ::klogctl(type, bufp, len);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getrandom, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getrandom, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, void *buf, size_t buflen, unsigned int flags) -> uint64_t {
uint64_t Result = ::getrandom(buf, buflen, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(capget, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(capget, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, cap_user_header_t hdrp, cap_user_data_t datap) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(capget), hdrp, datap);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(capset, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(capset, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, cap_user_header_t hdrp, const cap_user_data_t datap) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(capset), hdrp, datap);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(getcpu, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(getcpu, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, unsigned *cpu, unsigned *node, struct getcpu_cache *tcache) -> uint64_t {
uint32_t LocalCPU{};
uint32_t LocalNode{};
@@ -107,13 +107,13 @@ namespace FEX::HLE {
});
//compare two processes to determine if they share a kernel resource
REGISTER_SYSCALL_IMPL_PASS_FLAGS(kcmp, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(kcmp, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, pid_t pid1, pid_t pid2, int type, unsigned long idx1, unsigned long idx2) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(kcmp), pid1, pid2, type, idx1, idx2);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(seccomp, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(seccomp, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, unsigned int operation, unsigned int flags, void *args) -> uint64_t {
// FEX doesn't support seccomp
return -EINVAL;
Source/Tests/LinuxSyscalls/Syscalls/Key.cpp
+6 -6
View File
@@ -19,39 +19,39 @@ namespace FEX::HLE {
void RegisterKey() {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_PASS_FLAGS(add_key, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(add_key, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *type, const char *description, const void *payload, size_t plen, key_serial_t keyring) -> uint64_t {
uint64_t Result = syscall(SYS_add_key, type, description, payload, plen, keyring);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(request_key, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(request_key, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *type, const char *description, const char *callout_info, key_serial_t dest_keyring) -> uint64_t {
uint64_t Result = syscall(SYS_request_key, type, description, callout_info, dest_keyring);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(keyctl, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(keyctl, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int operation, uint64_t arg2, uint64_t arg3, uint64_t arg4, uint64_t arg5) -> uint64_t {
uint64_t Result = syscall(SYS_keyctl, operation, arg2, arg3, arg4, arg5);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pkey_mprotect, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pkey_mprotect, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, void *addr, size_t len, int prot, int pkey) -> uint64_t {
// Added in Linux 4.9
uint64_t Result = ::syscall(SYSCALL_DEF(pkey_mprotect), addr, len, prot, pkey);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pkey_alloc, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pkey_alloc, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, unsigned int flags, unsigned int access_rights) -> uint64_t {
// Added in Linux 4.9
uint64_t Result = ::syscall(SYSCALL_DEF(pkey_alloc), flags, access_rights);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pkey_free, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pkey_free, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int pkey) -> uint64_t {
// Added in Linux 4.9
uint64_t Result = ::syscall(SYSCALL_DEF(pkey_free), pkey);
Source/Tests/LinuxSyscalls/Syscalls/Memory.cpp
+14 -14
View File
@@ -20,86 +20,86 @@ namespace FEX::HLE {
void RegisterMemory() {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_FLAGS(brk, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(brk, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, void *addr) -> uint64_t {
uint64_t Result = FEX::HLE::_SyscallHandler->HandleBRK(Frame, addr);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(msync, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(msync, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, void *addr, size_t length, int32_t flags) -> uint64_t {
uint64_t Result = ::msync(addr, length, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mincore, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mincore, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, void *addr, size_t length, uint8_t *vec) -> uint64_t {
uint64_t Result = ::mincore(addr, length, vec);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(madvise, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(madvise, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, void *addr, size_t length, int32_t advice) -> uint64_t {
uint64_t Result = ::madvise(addr, length, advice);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mlock, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mlock, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const void *addr, size_t len) -> uint64_t {
uint64_t Result = ::mlock(addr, len);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(munlock, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(munlock, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const void *addr, size_t len) -> uint64_t {
uint64_t Result = ::munlock(addr, len);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mlock2, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mlock2, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const void *addr, size_t len, int flags) -> uint64_t {
uint64_t Result = ::mlock2(addr, len, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(remap_file_pages, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(remap_file_pages, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, void *addr, size_t size, int prot, size_t pgoff, int flags) -> uint64_t {
// This syscall is deprecated, not sure when it will end up being removed
uint64_t Result = ::remap_file_pages(addr, size, prot, pgoff, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mbind, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mbind, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, void *addr, unsigned long len, int mode, const unsigned long *nodemask, unsigned long maxnode, unsigned flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(mbind), addr, len, mode, nodemask, maxnode, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(get_mempolicy, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(get_mempolicy, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int *mode, unsigned long *nodemask, unsigned long maxnode, void *addr, unsigned long flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(get_mempolicy), mode, nodemask, maxnode, addr, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(set_mempolicy, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(set_mempolicy, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int mode, const unsigned long *nodemask, unsigned long maxnode) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(set_mempolicy), mode, nodemask, maxnode);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(migrate_pages, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(migrate_pages, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int pid, unsigned long maxnode, const unsigned long *old_nodes, const unsigned long *new_nodes) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(migrate_pages), pid, maxnode, old_nodes, new_nodes);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(move_pages, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(move_pages, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int pid, unsigned long count, void **pages, const int *nodes, int *status, int flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(move_pages), pid, count, pages, nodes, status, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(membarrier, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(membarrier, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int cmd, int flags) -> uint64_t {
uint64_t Result = syscall(SYSCALL_DEF(membarrier), cmd, flags);
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/Syscalls/Msg.cpp
+5 -5
View File
@@ -21,25 +21,25 @@ namespace FEX::HLE {
void RegisterMsg() {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_PASS_FLAGS(msgget, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(msgget, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, key_t key, int msgflg) -> uint64_t {
uint64_t Result = ::msgget(key, msgflg);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(msgsnd, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(msgsnd, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int msqid, const void *msgp, size_t msgsz, int msgflg) -> uint64_t {
uint64_t Result = ::msgsnd(msqid, msgp, msgsz, msgflg);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(msgrcv, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(msgrcv, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg) -> uint64_t {
uint64_t Result = ::msgrcv(msqid, msgp, msgsz, msgtyp, msgflg);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(msgctl, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(msgctl, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int msqid, int cmd, struct msqid_ds *buf) -> uint64_t {
// A quirk of this syscall
// On 32-bit this syscall ONLY supports IPC_64 msqid_ds encoding
@@ -50,7 +50,7 @@ namespace FEX::HLE {
});
// last two parameters are optional
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mq_unlink, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mq_unlink, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const char *name) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(mq_unlink), name);
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/Syscalls/Namespace.cpp
+7 -7
View File
@@ -25,37 +25,37 @@ namespace FEX::HLE {
using namespace FEXCore::IR;
if (Handler->GetHostKernelVersion() >= FEX::HLE::SyscallHandler::KernelVersion(5, 1, 0)) {
REGISTER_SYSCALL_IMPL_PASS_FLAGS(open_tree, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(open_tree, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dfd, const char *filename, unsigned int flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(open_tree), dfd, filename, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(move_mount, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(move_mount, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int from_dfd, const char *from_pathname, int to_dfd, const char *to_pathname, unsigned int flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(move_mount), from_dfd, from_pathname, to_dfd, to_pathname, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fsopen, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fsopen, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dfd, const char *path, unsigned int flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(fsopen), dfd, path, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fsconfig, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fsconfig, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, unsigned int cmd, const char *key, const void *value, int aux) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(fsconfig), fd, cmd, key, value, aux);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fsmount, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fsmount, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fs_fd, uint32_t flags, uint32_t attr_flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(fsmount), fs_fd, flags, attr_flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fspick, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(fspick, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dfd, const char *path, unsigned int flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(fspick), dfd, path, flags);
SYSCALL_ERRNO();
@@ -71,7 +71,7 @@ namespace FEX::HLE {
}
if (Handler->GetHostKernelVersion() >= FEX::HLE::SyscallHandler::KernelVersion(5, 12, 0)) {
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mount_setattr, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(mount_setattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int dfd, const char *path, unsigned int flags, void *uattr, size_t usize) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(mount_setattr), dfd, path, flags, uattr, usize);
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/Syscalls/SHM.cpp
+2 -2
View File
@@ -18,14 +18,14 @@ namespace FEX::HLE {
void RegisterSHM() {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_PASS_FLAGS(shmget, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(shmget, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, key_t key, size_t size, int shmflg) -> uint64_t {
uint64_t Result = shmget(key, size, shmflg);
SYSCALL_ERRNO();
});
// XXX: shmid_ds is definitely not correct for 32-bit
REGISTER_SYSCALL_IMPL_PASS_FLAGS(shmctl, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(shmctl, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int shmid, int cmd, struct shmid_ds *buf) -> uint64_t {
uint64_t Result = ::shmctl(shmid, cmd, buf);
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/Syscalls/Sched.cpp
+13 -13
View File
@@ -23,66 +23,66 @@ namespace FEX::HLE {
void RegisterSched() {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_yield, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_yield, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
uint64_t Result = ::sched_yield();
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getpriority, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getpriority, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int which, int who) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(getpriority), which, who);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setpriority, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setpriority, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int which, int who, int prio) -> uint64_t {
uint64_t Result = ::setpriority(which, who, prio);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_setparam, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_setparam, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, const struct sched_param *param) -> uint64_t {
uint64_t Result = ::sched_setparam(pid, param);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_getparam, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_getparam, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, struct sched_param *param) -> uint64_t {
uint64_t Result = ::sched_getparam(pid, param);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_setscheduler, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_setscheduler, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, int policy, const struct sched_param *param) -> uint64_t {
uint64_t Result = ::sched_setscheduler(pid, policy, param);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_getscheduler, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_getscheduler, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, pid_t pid) -> uint64_t {
uint64_t Result = ::sched_getscheduler(pid);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_get_priority_max, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_get_priority_max, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int policy) -> uint64_t {
uint64_t Result = ::sched_get_priority_max(policy);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_get_priority_min, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_get_priority_min, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int policy) -> uint64_t {
uint64_t Result = ::sched_get_priority_min(policy);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(sched_setaffinity, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY | SYSCALL_FLAG_NOSIDEEFFECTS,
REGISTER_SYSCALL_IMPL_FLAGS(sched_setaffinity, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY | SyscallFlags::NOSIDEEFFECTS,
[](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, size_t cpusetsize, const unsigned long *mask) -> uint64_t {
return 0;
});
REGISTER_SYSCALL_IMPL_FLAGS(sched_getaffinity, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(sched_getaffinity, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, size_t cpusetsize, unsigned char *mask) -> uint64_t {
uint64_t Cores = FEX::HLE::_SyscallHandler->ThreadsConfig();
@@ -110,13 +110,13 @@ namespace FEX::HLE {
return Bytes;
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_setattr, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_setattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, struct sched_attr *attr, unsigned int flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(sched_setattr), pid, attr, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_getattr, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sched_getattr, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, struct sched_attr *attr, unsigned int size, unsigned int flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(sched_getattr), pid, attr, size, flags);
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/Syscalls/Semaphore.cpp
+1 -1
View File
@@ -18,7 +18,7 @@ namespace FEX::HLE {
void RegisterSemaphore() {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_PASS_FLAGS(semget, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(semget, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, key_t key, int nsems, int semflg) -> uint64_t {
uint64_t Result = ::semget(key, nsems, semflg);
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/Syscalls/Socket.cpp
+11 -11
View File
@@ -18,67 +18,67 @@ namespace FEX::HLE {
void RegisterSocket() {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_PASS_FLAGS(socket, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(socket, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int domain, int type, int protocol) -> uint64_t {
uint64_t Result = ::socket(domain, type, protocol);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(connect, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(connect, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int sockfd, const struct sockaddr *addr, socklen_t addrlen) -> uint64_t {
uint64_t Result = ::connect(sockfd, addr, addrlen);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(accept4, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(accept4, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags) -> uint64_t {
uint64_t Result = ::accept4(sockfd, addr, addrlen, flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sendto, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(sendto, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen) -> uint64_t {
uint64_t Result = ::sendto(sockfd, buf, len, flags, dest_addr, addrlen);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(recvfrom, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(recvfrom, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen) -> uint64_t {
uint64_t Result = ::recvfrom(sockfd, buf, len, flags, src_addr, addrlen);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(shutdown, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(shutdown, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int sockfd, int how) -> uint64_t {
uint64_t Result = ::shutdown(sockfd, how);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(bind, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(bind, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int sockfd, const struct sockaddr *addr, socklen_t addrlen) -> uint64_t {
uint64_t Result = ::bind(sockfd, addr, addrlen);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(listen, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(listen, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int sockfd, int backlog) -> uint64_t {
uint64_t Result = ::listen(sockfd, backlog);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getsockname, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getsockname, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int sockfd, struct sockaddr *addr, socklen_t *addrlen) -> uint64_t {
uint64_t Result = ::getsockname(sockfd, addr, addrlen);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getpeername, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getpeername, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int sockfd, struct sockaddr *addr, socklen_t *addrlen) -> uint64_t {
uint64_t Result = ::getpeername(sockfd, addr, addrlen);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(socketpair, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(socketpair, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int domain, int type, int protocol, int sv[2]) -> uint64_t {
uint64_t Result = ::socketpair(domain, type, protocol, sv);
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/Syscalls/Thread.cpp
+40 -40
View File
@@ -252,28 +252,28 @@ namespace FEX::HLE {
void RegisterThread(FEX::HLE::SyscallHandler *const Handler) {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getpid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getpid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
uint64_t Result = ::getpid();
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(fork, SYSCALL_FLAG_DEFAULT, [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
REGISTER_SYSCALL_IMPL_FLAGS(fork, SyscallFlags::DEFAULT, [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
return ForkGuest(Frame->Thread, Frame, 0, 0, 0, 0, 0);
});
REGISTER_SYSCALL_IMPL_FLAGS(vfork, SYSCALL_FLAG_DEFAULT, [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
REGISTER_SYSCALL_IMPL_FLAGS(vfork, SyscallFlags::DEFAULT, [](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
return ForkGuest(Frame->Thread, Frame, CLONE_VFORK, 0, 0, 0, 0);
});
REGISTER_SYSCALL_IMPL_FLAGS(clone3, SYSCALL_FLAG_DEFAULT, ([](FEXCore::Core::CpuStateFrame *Frame, FEX::HLE::kernel_clone3_args *cl_args, size_t size) -> uint64_t {
REGISTER_SYSCALL_IMPL_FLAGS(clone3, SyscallFlags::DEFAULT, ([](FEXCore::Core::CpuStateFrame *Frame, FEX::HLE::kernel_clone3_args *cl_args, size_t size) -> uint64_t {
FEX::HLE::clone3_args args{};
args.Type = TypeOfClone::TYPE_CLONE3;
memcpy(&args.args, cl_args, std::min(sizeof(FEX::HLE::kernel_clone3_args), size));
return CloneHandler(Frame, &args);
}));
REGISTER_SYSCALL_IMPL_FLAGS(exit, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY | SYSCALL_FLAG_NORETURN,
REGISTER_SYSCALL_IMPL_FLAGS(exit, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY | SyscallFlags::NORETURN,
[](FEXCore::Core::CpuStateFrame *Frame, int status) -> uint64_t {
auto Thread = Frame->Thread;
if (Thread->ThreadManager.clear_child_tid) {
@@ -294,131 +294,131 @@ namespace FEX::HLE {
return 0;
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(kill, SYSCALL_FLAG_DEFAULT, [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, int sig) -> uint64_t {
REGISTER_SYSCALL_IMPL_PASS_FLAGS(kill, SyscallFlags::DEFAULT, [](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, int sig) -> uint64_t {
uint64_t Result = ::kill(pid, sig);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(tkill, SYSCALL_FLAG_DEFAULT, [](FEXCore::Core::CpuStateFrame *Frame, int tid, int sig) -> uint64_t {
REGISTER_SYSCALL_IMPL_PASS_FLAGS(tkill, SyscallFlags::DEFAULT, [](FEXCore::Core::CpuStateFrame *Frame, int tid, int sig) -> uint64_t {
// Can't actually use tgkill here, kernel rejects tgkill of tgid == 0
uint64_t Result = ::syscall(SYSCALL_DEF(tkill), tid, sig);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(tgkill, SYSCALL_FLAG_DEFAULT, [](FEXCore::Core::CpuStateFrame *Frame, int tgid, int tid, int sig) -> uint64_t {
REGISTER_SYSCALL_IMPL_PASS_FLAGS(tgkill, SyscallFlags::DEFAULT, [](FEXCore::Core::CpuStateFrame *Frame, int tgid, int tid, int sig) -> uint64_t {
uint64_t Result = FHU::Syscalls::tgkill(tgid, tid, sig);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getuid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getuid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
uint64_t Result = ::getuid();
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getgid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getgid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
uint64_t Result = ::getgid();
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setuid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setuid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, uid_t uid) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(setuid), uid);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setgid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setgid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, gid_t gid) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(setgid), gid);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(geteuid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(geteuid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
uint64_t Result = ::geteuid();
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getegid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getegid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
uint64_t Result = ::getegid();
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getppid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getppid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
uint64_t Result = ::getppid();
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getpgrp, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getpgrp, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
uint64_t Result = ::getpgrp();
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setsid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setsid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
uint64_t Result = ::setsid();
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setreuid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setreuid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, uid_t ruid, uid_t euid) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(setreuid), ruid, euid);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setregid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setregid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, gid_t rgid, gid_t egid) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(setregid), rgid, egid);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getgroups, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getgroups, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int size, gid_t list[]) -> uint64_t {
uint64_t Result = ::getgroups(size, list);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setgroups, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setgroups, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, size_t size, const gid_t *list) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(setgroups), size, list);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setresuid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setresuid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, uid_t ruid, uid_t euid, uid_t suid) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(setresuid), ruid, euid, suid);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getresuid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getresuid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, uid_t *ruid, uid_t *euid, uid_t *suid) -> uint64_t {
uint64_t Result = ::getresuid(ruid, euid, suid);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setresgid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setresgid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, gid_t rgid, gid_t egid, gid_t sgid) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(setresgid), rgid, egid, sgid);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getresgid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getresgid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, gid_t *rgid, gid_t *egid, gid_t *sgid) -> uint64_t {
uint64_t Result = ::getresgid(rgid, egid, sgid);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(personality, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(personality, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, uint64_t persona) -> uint64_t {
uint64_t Result = ::personality(persona);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(prctl, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_FLAGS(prctl, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5) -> uint64_t {
uint64_t Result{};
switch (option) {
@@ -434,7 +434,7 @@ namespace FEX::HLE {
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_FLAGS(arch_prctl, SYSCALL_FLAG_DEFAULT,
REGISTER_SYSCALL_IMPL_FLAGS(arch_prctl, SyscallFlags::DEFAULT,
[](FEXCore::Core::CpuStateFrame *Frame, int code, unsigned long addr) -> uint64_t {
constexpr uint64_t TASK_MAX = (1ULL << 48); // 48-bits until we can query the host side VA sanely. AArch64 doesn't expose this in cpuinfo
uint64_t Result{};
@@ -480,20 +480,20 @@ namespace FEX::HLE {
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(gettid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(gettid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
uint64_t Result = FHU::Syscalls::gettid();
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(set_tid_address, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(set_tid_address, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int *tidptr) -> uint64_t {
auto Thread = Frame->Thread;
Thread->ThreadManager.clear_child_tid = tidptr;
return Thread->ThreadManager.GetTID();
});
REGISTER_SYSCALL_IMPL_FLAGS(exit_group, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY | SYSCALL_FLAG_NORETURN,
REGISTER_SYSCALL_IMPL_FLAGS(exit_group, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY | SyscallFlags::NORETURN,
[](FEXCore::Core::CpuStateFrame *Frame, int status) -> uint64_t {
auto Thread = Frame->Thread;
Thread->StatusCode = status;
@@ -502,56 +502,56 @@ namespace FEX::HLE {
std::terminate();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(prlimit_64, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(prlimit_64, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, int resource, const struct rlimit *new_limit, struct rlimit *old_limit) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(prlimit_64), pid, resource, new_limit, old_limit);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setpgid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setpgid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, pid_t pgid) -> uint64_t {
uint64_t Result = ::setpgid(pid, pgid);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getpgid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getpgid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, pid_t pid) -> uint64_t {
uint64_t Result = ::getpgid(pid);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setfsuid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setfsuid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, uid_t fsuid) -> uint64_t {
uint64_t Result = ::setfsuid(fsuid);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setfsgid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setfsgid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, uid_t fsgid) -> uint64_t {
uint64_t Result = ::setfsgid(fsgid);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getsid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(getsid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, pid_t pid) -> uint64_t {
uint64_t Result = ::getsid(pid);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(unshare, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(unshare, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int flags) -> uint64_t {
uint64_t Result = ::unshare(flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setns, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(setns, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int fd, int nstype) -> uint64_t {
uint64_t Result = ::setns(fd, nstype);
SYSCALL_ERRNO();
});
if (Handler->IsHostKernelVersionAtLeast(5, 16, 0)) {
REGISTER_SYSCALL_IMPL_PASS_FLAGS(futex_waitv, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(futex_waitv, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, void *waiters, uint32_t nr_futexes, uint32_t flags, struct timespec *timeout, clockid_t clockid) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(futex_waitv), waiters, nr_futexes, flags, timeout, clockid);
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/Syscalls/Time.cpp
+1 -1
View File
@@ -16,7 +16,7 @@ namespace FEX::HLE {
void RegisterTime() {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pause, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(pause, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
uint64_t Result = ::pause();
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/Syscalls/Timer.cpp
+3 -3
View File
@@ -23,19 +23,19 @@ namespace FEX::HLE {
void RegisterTimer() {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_PASS_FLAGS(alarm, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(alarm, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, unsigned int seconds) -> uint64_t {
uint64_t Result = ::alarm(seconds);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(timer_getoverrun, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(timer_getoverrun, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, kernel_timer_t timerid) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(timer_getoverrun), timerid);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_PASS_FLAGS(timer_delete, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_PASS_FLAGS(timer_delete, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, kernel_timer_t timerid) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(timer_delete), timerid);
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/x32/Ioctl/ext_fs.h
+17
View File
@@ -0,0 +1,17 @@
#pragma once
#include "Tests/LinuxSyscalls/x32/Types.h"
#include "Tests/LinuxSyscalls/x32/Ioctl/HelperDefines.h"
#include <cstdint>
#include <linux/blktrace_api.h>
#include <linux/fs.h>
#include <linux/fiemap.h>
#include <sys/ioctl.h>
namespace FEX::HLE::x32 {
namespace ext_fs {
#include "Tests/LinuxSyscalls/x32/Ioctl/ext_fs.inl"
}
}
Source/Tests/LinuxSyscalls/x32/Ioctl/ext_fs.inl
+52
View File
@@ -0,0 +1,52 @@
_BASIC_META(BLKROSET)
_BASIC_META(BLKROGET)
_BASIC_META(BLKRRPART)
_BASIC_META(BLKGETSIZE)
_BASIC_META(BLKFLSBUF)
_BASIC_META(BLKRASET)
_BASIC_META(BLKRAGET)
_BASIC_META(BLKFRASET)
_BASIC_META(BLKFRAGET)
_BASIC_META(BLKSECTSET)
_BASIC_META(BLKSECTGET)
_BASIC_META(BLKSSZGET)
_BASIC_META(BLKBSZGET)
_BASIC_META(BLKBSZSET)
_BASIC_META(BLKGETSIZE64)
_BASIC_META(BLKTRACESETUP)
_BASIC_META(BLKTRACESTART)
_BASIC_META(BLKTRACESTOP)
_BASIC_META(BLKTRACETEARDOWN)
_BASIC_META(BLKDISCARD)
_BASIC_META(BLKIOMIN)
_BASIC_META(BLKIOOPT)
_BASIC_META(BLKALIGNOFF)
_BASIC_META(BLKPBSZGET)
_BASIC_META(BLKDISCARDZEROES)
_BASIC_META(BLKSECDISCARD)
_BASIC_META(BLKROTATIONAL)
_BASIC_META(BLKZEROOUT)
_BASIC_META(FIBMAP)
_BASIC_META(FIGETBSZ)
_BASIC_META(FIFREEZE)
_BASIC_META(FITHAW)
_BASIC_META(FITRIM)
_BASIC_META(FICLONE)
_BASIC_META(FICLONERANGE)
_BASIC_META(FIDEDUPERANGE)
_BASIC_META(FS_IOC_GETFLAGS)
_BASIC_META(FS_IOC_SETFLAGS)
_BASIC_META(FS_IOC_GETVERSION)
_BASIC_META(FS_IOC_SETVERSION)
_BASIC_META(FS_IOC_FIEMAP)
_BASIC_META(FS_IOC32_GETFLAGS)
_BASIC_META(FS_IOC32_SETFLAGS)
_BASIC_META(FS_IOC32_GETVERSION)
_BASIC_META(FS_IOC32_SETVERSION)
_BASIC_META(FS_IOC_FSGETXATTR)
_BASIC_META(FS_IOC_FSSETXATTR)
_BASIC_META(FS_IOC_GETFSLABEL)
_BASIC_META(FS_IOC_SETFSLABEL)
Source/Tests/LinuxSyscalls/x32/Ioctl/f2fs.h
+42
View File
@@ -0,0 +1,42 @@
#include "Tests/LinuxSyscalls/x32/Types.h"
#include "Tests/LinuxSyscalls/x32/Ioctl/HelperDefines.h"
#include <cstdint>
#include <sys/ioctl.h>
namespace FEX::HLE::x32 {
namespace f2fs {
// There is no userspace definitions for these
// Must define everything ourselves
constexpr uint32_t F2FS_IOCTL_MAGIC = 0xf5;
#define F2FS_IOC_START_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 1)
#define F2FS_IOC_COMMIT_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 2)
#define F2FS_IOC_START_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 3)
#define F2FS_IOC_RELEASE_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 4)
#define F2FS_IOC_ABORT_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 5)
#define F2FS_IOC_GARBAGE_COLLECT _IOW(F2FS_IOCTL_MAGIC, 6, uint32_t)
#define F2FS_IOC_WRITE_CHECKPOINT _IO(F2FS_IOCTL_MAGIC, 7)
//#define F2FS_IOC_DEFRAGMENT _IOWR(F2FS_IOCTL_MAGIC, 8, \
// struct f2fs_defragment)
//#define F2FS_IOC_MOVE_RANGE _IOWR(F2FS_IOCTL_MAGIC, 9, \
// struct f2fs_move_range)
//#define F2FS_IOC_FLUSH_DEVICE _IOW(F2FS_IOCTL_MAGIC, 10, \
// struct f2fs_flush_device)
//#define F2FS_IOC_GARBAGE_COLLECT_RANGE _IOW(F2FS_IOCTL_MAGIC, 11, \
// struct f2fs_gc_range)
#define F2FS_IOC_GET_FEATURES _IOR(F2FS_IOCTL_MAGIC, 12, uint32_t)
#define F2FS_IOC_SET_PIN_FILE _IOW(F2FS_IOCTL_MAGIC, 13, uint32_t)
#define F2FS_IOC_GET_PIN_FILE _IOR(F2FS_IOCTL_MAGIC, 14, uint32_t)
#define F2FS_IOC_PRECACHE_EXTENTS _IO(F2FS_IOCTL_MAGIC, 15)
#define F2FS_IOC_RESIZE_FS _IOW(F2FS_IOCTL_MAGIC, 16, uint64_t)
#define F2FS_IOC_GET_COMPRESS_BLOCKS _IOR(F2FS_IOCTL_MAGIC, 17, uint64_t)
#define F2FS_IOC_RELEASE_COMPRESS_BLOCKS \
_IOR(F2FS_IOCTL_MAGIC, 18, uint64_t)
#define F2FS_IOC_RESERVE_COMPRESS_BLOCKS \
_IOR(F2FS_IOCTL_MAGIC, 19, uint64_t)
//#define F2FS_IOC_SEC_TRIM_FILE _IOW(F2FS_IOCTL_MAGIC, 20, \
// struct f2fs_sectrim_range)
#include "Tests/LinuxSyscalls/x32/Ioctl/f2fs.inl"
}
}
Source/Tests/LinuxSyscalls/x32/Ioctl/f2fs.inl
+21
View File
@@ -0,0 +1,21 @@
_BASIC_META(F2FS_IOC_START_ATOMIC_WRITE)
_BASIC_META(F2FS_IOC_COMMIT_ATOMIC_WRITE)
_BASIC_META(F2FS_IOC_START_VOLATILE_WRITE)
_BASIC_META(F2FS_IOC_RELEASE_VOLATILE_WRITE)
_BASIC_META(F2FS_IOC_ABORT_VOLATILE_WRITE)
_BASIC_META(F2FS_IOC_GARBAGE_COLLECT)
_BASIC_META(F2FS_IOC_WRITE_CHECKPOINT)
//_CUSTOM_META(F2FS_IOC_DEFRAGMENT, XXX)
//_CUSTOM_META(F2FS_IOC_MOVE_RANGE, XXX)
//_CUSTOM_META(F2FS_IOC_FLUSH_DEVICE, XXX)
//_CUSTOM_META(F2FS_IOC_GARBAGE_COLLECT_RANGE, XXX)
_BASIC_META(F2FS_IOC_GET_FEATURES)
_BASIC_META(F2FS_IOC_SET_PIN_FILE)
_BASIC_META(F2FS_IOC_GET_PIN_FILE)
_BASIC_META(F2FS_IOC_PRECACHE_EXTENTS)
_BASIC_META(F2FS_IOC_RESIZE_FS)
_BASIC_META(F2FS_IOC_GET_COMPRESS_BLOCKS)
_BASIC_META(F2FS_IOC_RELEASE_COMPRESS_BLOCKS)
_BASIC_META(F2FS_IOC_RESERVE_COMPRESS_BLOCKS)
//_CUSTOM_META(F2FS_IOC_SEC_TRIM_FILE, XXX)
Source/Tests/LinuxSyscalls/x32/Ioctl/msdos_fs.h
+15
View File
@@ -0,0 +1,15 @@
#pragma once
#include "Tests/LinuxSyscalls/x32/Types.h"
#include "Tests/LinuxSyscalls/x32/Ioctl/HelperDefines.h"
#include <cstdint>
#include <linux/msdos_fs.h>
#include <sys/ioctl.h>
namespace FEX::HLE::x32 {
namespace msdos_fs {
#include "Tests/LinuxSyscalls/x32/Ioctl/msdos_fs.inl"
}
}
Source/Tests/LinuxSyscalls/x32/Ioctl/msdos_fs.inl
+5
View File
@@ -0,0 +1,5 @@
_BASIC_META(VFAT_IOCTL_READDIR_BOTH)
_BASIC_META(VFAT_IOCTL_READDIR_SHORT)
_BASIC_META(FAT_IOCTL_GET_ATTRIBUTES)
_BASIC_META(FAT_IOCTL_SET_ATTRIBUTES)
_BASIC_META(FAT_IOCTL_GET_VOLUME_ID)
Source/Tests/LinuxSyscalls/x32/Ioctls.inl
+1
View File
@@ -0,0 +1 @@
IOCTL(DRM_IOCTL_VERSION, FEX::HLE::x32::DRM::Handler)
Source/Tests/LinuxSyscalls/x32/Syscalls.cpp
+2 -2
View File
@@ -66,7 +66,7 @@ namespace FEX::HLE::x32 {
void* SyscallHandler;
int ArgumentCount;
int32_t HostSyscallNumber;
uint8_t Flags;
FEXCore::IR::SyscallFlags Flags;
#ifdef DEBUG_STRACE
std::string TraceFormatString;
#endif
@@ -76,7 +76,7 @@ namespace FEX::HLE::x32 {
void RegisterSyscallInternal(int SyscallNumber,
int32_t HostSyscallNumber,
uint8_t Flags,
FEXCore::IR::SyscallFlags Flags,
#ifdef DEBUG_STRACE
const std::string& TraceFormatString,
#endif
Source/Tests/LinuxSyscalls/x32/Syscalls.h
+7 -8
View File
@@ -46,7 +46,7 @@ std::unique_ptr<FEX::HLE::SyscallHandler> CreateHandler(FEXCore::Context::Contex
void RegisterSyscallInternal(int SyscallNumber,
int32_t HostSyscallNumber,
uint8_t Flags,
FEXCore::IR::SyscallFlags Flags,
#ifdef DEBUG_STRACE
const std::string& TraceFormatString,
#endif
@@ -62,7 +62,7 @@ void RegisterSyscallInternal(int SyscallNumber,
// Deduces return, args... from the function passed
// Does not work with lambas, because they are objects with operator (), not functions
template<typename R, typename ...Args>
bool RegisterSyscall(int SyscallNumber, int32_t HostSyscallNumber, uint8_t Flags, const char *Name, R(*fn)(FEXCore::Core::CpuStateFrame *Frame, Args...)) {
void RegisterSyscall(int SyscallNumber, int32_t HostSyscallNumber, FEXCore::IR::SyscallFlags Flags, const char *Name, R(*fn)(FEXCore::Core::CpuStateFrame *Frame, Args...)) {
#ifdef DEBUG_STRACE
auto TraceFormatString = std::string(Name) + "(" + CollectArgsFmtString<Args...>() + ") = %ld";
#endif
@@ -73,7 +73,6 @@ bool RegisterSyscall(int SyscallNumber, int32_t HostSyscallNumber, uint8_t Flags
TraceFormatString,
#endif
reinterpret_cast<void*>(fn), sizeof...(Args));
return true;
}
//LambdaTraits extracts the function singature of a lambda from operator()
@@ -90,9 +89,9 @@ struct LambdaTraits<T (C::*)(Args...) const>
// Non-capturing lambdas can be cast to function pointers, but this does not happen on argument matching
// This is some glue logic that will cast a lambda and call the base RegisterSyscall implementation
template<class F>
bool RegisterSyscall(int num, int32_t HostSyscallNumber, uint8_t Flags, const char *name, F f){
void RegisterSyscall(int num, int32_t HostSyscallNumber, FEXCore::IR::SyscallFlags Flags, const char *name, F f){
typedef typename LambdaTraits<decltype(&F::operator())>::Type Signature;
return RegisterSyscall(num, HostSyscallNumber, Flags, name, (Signature)f);
RegisterSyscall(num, HostSyscallNumber, Flags, name, (Signature)f);
}
}
@@ -102,7 +101,7 @@ bool RegisterSyscall(int num, int32_t HostSyscallNumber, uint8_t Flags, const ch
struct impl_##name { \
impl_##name() \
{ \
FEX::HLE::x32::RegisterSyscall(x32::SYSCALL_x86_##name, ~0, FEXCore::IR::SYSCALL_FLAG_DEFAULT, #name, lambda); \
FEX::HLE::x32::RegisterSyscall(x32::SYSCALL_x86_##name, ~0, FEXCore::IR::SyscallFlags::DEFAULT, #name, lambda); \
} } impl_##name
// Registers syscall for 32bit only
@@ -110,14 +109,14 @@ bool RegisterSyscall(int num, int32_t HostSyscallNumber, uint8_t Flags, const ch
struct impl_##name { \
impl_##name() \
{ \
FEX::HLE::x32::RegisterSyscall(x32::SYSCALL_x86_##name, SYSCALL_DEF(name), FEXCore::IR::SYSCALL_FLAG_DEFAULT, #name, lambda); \
FEX::HLE::x32::RegisterSyscall(x32::SYSCALL_x86_##name, SYSCALL_DEF(name), FEXCore::IR::SyscallFlags::DEFAULT, #name, lambda); \
} } impl_##name
#define REGISTER_SYSCALL_IMPL_X32_PASS_MANUAL(name, hostname, lambda) \
struct impl_##name { \
impl_##name() \
{ \
FEX::HLE::x32::RegisterSyscall(x32::SYSCALL_x86_##name, SYSCALL_DEF(hostname), FEXCore::IR::SYSCALL_FLAG_DEFAULT, #name, lambda); \
FEX::HLE::x32::RegisterSyscall(x32::SYSCALL_x86_##name, SYSCALL_DEF(hostname), FEXCore::IR::SyscallFlags::DEFAULT, #name, lambda); \
} } impl_##name
Source/Tests/LinuxSyscalls/x64/Ioctl/HelperDefines.h
+50
View File
@@ -0,0 +1,50 @@
#pragma once
#define STRINGY2(x, y) x##y
#define STRINGY(x, y) STRINGY2(x, y)
#define STRINGY12(x) STRINGY11(x)
#define STRINGY11(x) #x
#define STRINGY1(x) STRINGY12(x)
#ifndef _BASIC_META
// Meta typedef variable in unnamed and matches upstream
// Use this for the super basic ioctl passthrough path
#define _BASIC_META(x) __attribute__((annotate("fex-match"))) __attribute__((annotate("ioctl-alias-x86_64-_"#x STRINGY1(__LINE__)))) typedef uint8_t STRINGY(_##x, __LINE__)[x];
#endif
#ifndef _BASIC_META_VAR
// This is similar to _BASIC_META except that it allows you to pass variadic arguments to the original ioctl definition
#define _BASIC_META_VAR(x, args...) __attribute__((annotate("fex-match"))) __attribute__((annotate("ioctl-alias-x86_64-_"#x STRINGY1(__LINE__)))) typedef uint8_t STRINGY(_##x, __LINE__)[x(args)];
#endif
#ifndef _CUSTOM_META
// IOCTL doesn't match across architecture
// Generates a FEX_<name> version of the ioctl with custom ioctl definition
// eg: _CUSTOM_META(DRM_IOCTL_AMDGPU_GEM_METADATA, DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_METADATA, FEX::HLE::x64::AMDGPU::fex_drm_amdgpu_gem_metadata));
// Allows you to effectively pass in the original ioctl definition with custom type replacing the upstream type
#define _CUSTOM_META(name, ioctl_num) \
typedef uint8_t _meta_##name[name]; \
__attribute__((annotate("ioctl-alias-x86_64-_meta_"#name))) typedef uint8_t _##name[ioctl_num]; \
constexpr static uint32_t FEX_##name = ioctl_num;
#endif
#ifndef _CUSTOM_META_MATCH
// IOCTL doesn't match across architecture
// Generates a FEX_<name> version of the ioctl with custom ioctl definition
// eg: _CUSTOM_META(DRM_IOCTL_AMDGPU_GEM_METADATA, DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_METADATA, FEX::HLE::x64::AMDGPU::fex_drm_amdgpu_gem_metadata));
// Allows you to effectively pass in the original ioctl definition with custom type replacing the upstream type
#define _CUSTOM_META_MATCH(name, ioctl_num) \
typedef uint8_t _meta_##name[ioctl_num]; \
__attribute__((annotate("fex-match"))) typedef uint8_t _##name[ioctl_num]; \
constexpr static uint32_t FEX_##name = ioctl_num;
#endif
#ifndef _CUSTOM_META_OFFSET
// Same as _CUSTOM_META but allows you to define multiple types from an offset
// Required to have an ioctl covering a range which some ioctls do
#define _CUSTOM_META_OFFSET(name, ioctl_num, offset) \
typedef uint8_t _meta_##name[ioctl_num + offset]; \
__attribute__((annotate("ioctl-alias-x86_64-_meta_"#name))) typedef uint8_t _##name[ioctl_num + offset]; \
constexpr static uint32_t FEX_##name = ioctl_num + offset;
#endif
Source/Tests/LinuxSyscalls/x64/Ioctl/amdgpu_drm.inl
+16
View File
@@ -0,0 +1,16 @@
_BASIC_META(DRM_IOCTL_AMDGPU_GEM_CREATE)
_BASIC_META(DRM_IOCTL_AMDGPU_GEM_MMAP)
_BASIC_META(DRM_IOCTL_AMDGPU_CTX)
_BASIC_META(DRM_IOCTL_AMDGPU_BO_LIST)
_BASIC_META(DRM_IOCTL_AMDGPU_CS)
_BASIC_META(DRM_IOCTL_AMDGPU_INFO)
_BASIC_META(DRM_IOCTL_AMDGPU_GEM_METADATA)
_BASIC_META(DRM_IOCTL_AMDGPU_GEM_WAIT_IDLE)
_BASIC_META(DRM_IOCTL_AMDGPU_GEM_VA)
_BASIC_META(DRM_IOCTL_AMDGPU_WAIT_CS)
_BASIC_META(DRM_IOCTL_AMDGPU_GEM_OP)
_BASIC_META(DRM_IOCTL_AMDGPU_GEM_USERPTR)
_BASIC_META(DRM_IOCTL_AMDGPU_WAIT_FENCES)
_BASIC_META(DRM_IOCTL_AMDGPU_VM)
_BASIC_META(DRM_IOCTL_AMDGPU_FENCE_TO_HANDLE)
_BASIC_META(DRM_IOCTL_AMDGPU_SCHED)
Source/Tests/LinuxSyscalls/x64/Ioctl/asound.h
+21
View File
@@ -0,0 +1,21 @@
#include "Tests/LinuxSyscalls/x64/Types.h"
#include "Tests/LinuxSyscalls/x64/Ioctl/HelperDefines.h"
#include <cstdint>
#include <sound/asound.h>
#include <sys/ioctl.h>
namespace FEX::HLE::x64 {
namespace asound {
#ifndef SNDRV_TIMER_IOCTL_TREAD_OLD
#define SNDRV_TIMER_IOCTL_TREAD_OLD _IOW('T', 0x02, int)
#endif
#ifndef SNDRV_TIMER_IOCTL_TREAD64
#define SNDRV_TIMER_IOCTL_TREAD64 _IOW('T', 0xa4, int)
#endif
#include "Tests/LinuxSyscalls/x64/Ioctl/asound.inl"
}
}
Source/Tests/LinuxSyscalls/x64/Ioctl/asound.inl
+87
View File
@@ -0,0 +1,87 @@
_BASIC_META(SNDRV_HWDEP_IOCTL_PVERSION)
_BASIC_META(SNDRV_HWDEP_IOCTL_INFO)
_BASIC_META(SNDRV_HWDEP_IOCTL_DSP_STATUS)
//_BASIC_META(SNDRV_HWDEP_IOCTL_DSP_LOAD)
_BASIC_META(SNDRV_PCM_IOCTL_PVERSION)
_BASIC_META(SNDRV_PCM_IOCTL_INFO)
_BASIC_META(SNDRV_PCM_IOCTL_TSTAMP)
_BASIC_META(SNDRV_PCM_IOCTL_TTSTAMP)
_BASIC_META(SNDRV_PCM_IOCTL_USER_PVERSION)
// XXX: _BASIC_META(SNDRV_PCM_IOCTL_HW_REFINE)
// XXX: _BASIC_META(SNDRV_PCM_IOCTL_HW_PARAMS)
_BASIC_META(SNDRV_PCM_IOCTL_HW_FREE)
// XXX: _BASIC_META(SNDRV_PCM_IOCTL_SW_PARAMS)
// XXX: _BASIC_META(SNDRV_PCM_IOCTL_STATUS)
// XXX: _BASIC_META(SNDRV_PCM_IOCTL_DELAY)
_BASIC_META(SNDRV_PCM_IOCTL_HWSYNC)
// XXX: _BASIC_META(__SNDRV_PCM_IOCTL_SYNC_PTR)
// XXX: _BASIC_META(__SNDRV_PCM_IOCTL_SYNC_PTR64)
// XXX: _BASIC_META(SNDRV_PCM_IOCTL_SYNC_PTR)
// XXX: _BASIC_META(SNDRV_PCM_IOCTL_STATUS_EXT)
// XXX: _BASIC_META(SNDRV_PCM_IOCTL_CHANNEL_INFO)
_BASIC_META(SNDRV_PCM_IOCTL_PREPARE)
_BASIC_META(SNDRV_PCM_IOCTL_RESET)
_BASIC_META(SNDRV_PCM_IOCTL_START)
_BASIC_META(SNDRV_PCM_IOCTL_DROP)
_BASIC_META(SNDRV_PCM_IOCTL_DRAIN)
_BASIC_META(SNDRV_PCM_IOCTL_PAUSE)
// XXX: _BASIC_META(SNDRV_PCM_IOCTL_REWIND)
_BASIC_META(SNDRV_PCM_IOCTL_RESUME)
_BASIC_META(SNDRV_PCM_IOCTL_XRUN)
// XXX: _BASIC_META(SNDRV_PCM_IOCTL_FORWARD)
// XXX: _BASIC_META(SNDRV_PCM_IOCTL_WRITEI_FRAMES)
// XXX: _BASIC_META(SNDRV_PCM_IOCTL_READI_FRAMES)
// XXX: _BASIC_META(SNDRV_PCM_IOCTL_WRITEN_FRAMES)
// XXX: _BASIC_META(SNDRV_PCM_IOCTL_READN_FRAMES)
_BASIC_META(SNDRV_PCM_IOCTL_LINK)
_BASIC_META(SNDRV_PCM_IOCTL_UNLINK)
_BASIC_META(SNDRV_RAWMIDI_IOCTL_PVERSION)
_BASIC_META(SNDRV_RAWMIDI_IOCTL_INFO)
// XXX: _BASIC_META(SNDRV_RAWMIDI_IOCTL_PARAMS)
// XXX: _BASIC_META(SNDRV_RAWMIDI_IOCTL_STATUS)
_BASIC_META(SNDRV_RAWMIDI_IOCTL_DROP)
_BASIC_META(SNDRV_RAWMIDI_IOCTL_DRAIN)
_BASIC_META(SNDRV_TIMER_IOCTL_PVERSION)
_BASIC_META(SNDRV_TIMER_IOCTL_NEXT_DEVICE)
_BASIC_META(SNDRV_TIMER_IOCTL_TREAD_OLD)
// XXX: _BASIC_META(SNDRV_TIMER_IOCTL_GINFO)
// XXX: _BASIC_META(SNDRV_TIMER_IOCTL_GPARAMS)
// XXX: _BASIC_META(SNDRV_TIMER_IOCTL_GSTATUS)
_BASIC_META(SNDRV_TIMER_IOCTL_SELECT)
// XXX: _BASIC_META(SNDRV_TIMER_IOCTL_INFO)
_BASIC_META(SNDRV_TIMER_IOCTL_PARAMS)
// XXX: _BASIC_META(SNDRV_TIMER_IOCTL_STATUS)
_BASIC_META(SNDRV_TIMER_IOCTL_START)
_BASIC_META(SNDRV_TIMER_IOCTL_STOP)
_BASIC_META(SNDRV_TIMER_IOCTL_CONTINUE)
_BASIC_META(SNDRV_TIMER_IOCTL_PAUSE)
_BASIC_META(SNDRV_TIMER_IOCTL_TREAD64)
_BASIC_META(SNDRV_CTL_IOCTL_PVERSION)
_BASIC_META(SNDRV_CTL_IOCTL_CARD_INFO)
// XXX: _BASIC_META(SNDRV_CTL_IOCTL_ELEM_LIST)
_BASIC_META(SNDRV_CTL_IOCTL_ELEM_INFO)
// XXX: _BASIC_META(SNDRV_CTL_IOCTL_ELEM_READ)
// XXX: _BASIC_META(SNDRV_CTL_IOCTL_ELEM_WRITE)
_BASIC_META(SNDRV_CTL_IOCTL_ELEM_LOCK)
_BASIC_META(SNDRV_CTL_IOCTL_ELEM_UNLOCK)
_BASIC_META(SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS)
_BASIC_META(SNDRV_CTL_IOCTL_ELEM_ADD)
_BASIC_META(SNDRV_CTL_IOCTL_ELEM_REPLACE)
_BASIC_META(SNDRV_CTL_IOCTL_ELEM_REMOVE)
_BASIC_META(SNDRV_CTL_IOCTL_TLV_READ)
_BASIC_META(SNDRV_CTL_IOCTL_TLV_WRITE)
_BASIC_META(SNDRV_CTL_IOCTL_TLV_COMMAND)
_BASIC_META(SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE)
_BASIC_META(SNDRV_CTL_IOCTL_HWDEP_INFO)
_BASIC_META(SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE)
_BASIC_META(SNDRV_CTL_IOCTL_PCM_INFO)
_BASIC_META(SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE)
_BASIC_META(SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE)
_BASIC_META(SNDRV_CTL_IOCTL_RAWMIDI_INFO)
_BASIC_META(SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE)
_BASIC_META(SNDRV_CTL_IOCTL_POWER)
_BASIC_META(SNDRV_CTL_IOCTL_POWER_STATE)
Source/Tests/LinuxSyscalls/x64/Ioctl/drm.h
+31
View File
@@ -0,0 +1,31 @@
#pragma once
#include <FEXCore/Utils/CompilerDefs.h>
#include "Tests/LinuxSyscalls/x64/Types.h"
#include "Tests/LinuxSyscalls/x64/Ioctl/HelperDefines.h"
#include <cstdint>
#include <drm/drm.h>
#include <drm/drm_mode.h>
#include <drm/i915_drm.h>
#include <drm/amdgpu_drm.h>
#include <drm/lima_drm.h>
#include <drm/panfrost_drm.h>
#include <drm/msm_drm.h>
#include <drm/nouveau_drm.h>
#include <drm/vc4_drm.h>
#include <drm/v3d_drm.h>
#include <sys/ioctl.h>
#define CPYT(x) val.x = x
#define CPYF(x) x = val.x
namespace FEX::HLE::x64 {
#include "Tests/LinuxSyscalls/x64/Ioctl/drm.inl"
#include "Tests/LinuxSyscalls/x64/Ioctl/amdgpu_drm.inl"
#include "Tests/LinuxSyscalls/x64/Ioctl/msm_drm.inl"
}
#undef CPYT
#undef CPYF
Source/Tests/LinuxSyscalls/x64/Ioctl/drm.inl
+124
View File
@@ -0,0 +1,124 @@
_CUSTOM_META(DRM_IOCTL_VERSION, DRM_IOWR(0x00, struct drm_version))
_BASIC_META(DRM_IOCTL_GET_UNIQUE)
_BASIC_META(DRM_IOCTL_GET_MAGIC)
_BASIC_META(DRM_IOCTL_IRQ_BUSID)
_BASIC_META(DRM_IOCTL_GET_MAP)
_BASIC_META(DRM_IOCTL_GET_CLIENT)
_BASIC_META(DRM_IOCTL_GET_STATS)
_BASIC_META(DRM_IOCTL_SET_VERSION)
_BASIC_META(DRM_IOCTL_MODESET_CTL)
_BASIC_META(DRM_IOCTL_GEM_CLOSE)
_BASIC_META(DRM_IOCTL_GEM_FLINK)
_BASIC_META(DRM_IOCTL_GEM_OPEN)
_BASIC_META(DRM_IOCTL_GET_CAP)
_BASIC_META(DRM_IOCTL_SET_CLIENT_CAP)
_BASIC_META(DRM_IOCTL_SET_UNIQUE)
_BASIC_META(DRM_IOCTL_AUTH_MAGIC)
_BASIC_META(DRM_IOCTL_BLOCK)
_BASIC_META(DRM_IOCTL_UNBLOCK)
_BASIC_META(DRM_IOCTL_CONTROL)
_BASIC_META(DRM_IOCTL_ADD_MAP)
_BASIC_META(DRM_IOCTL_ADD_BUFS)
_BASIC_META(DRM_IOCTL_MARK_BUFS)
_BASIC_META(DRM_IOCTL_INFO_BUFS)
_BASIC_META(DRM_IOCTL_MAP_BUFS)
_BASIC_META(DRM_IOCTL_FREE_BUFS)
_BASIC_META(DRM_IOCTL_RM_MAP)
_BASIC_META(DRM_IOCTL_SET_SAREA_CTX)
_BASIC_META(DRM_IOCTL_GET_SAREA_CTX)
_BASIC_META(DRM_IOCTL_SET_MASTER)
_BASIC_META(DRM_IOCTL_DROP_MASTER)
_BASIC_META(DRM_IOCTL_ADD_CTX)
_BASIC_META(DRM_IOCTL_RM_CTX)
_BASIC_META(DRM_IOCTL_MOD_CTX)
_BASIC_META(DRM_IOCTL_GET_CTX)
_BASIC_META(DRM_IOCTL_SWITCH_CTX)
_BASIC_META(DRM_IOCTL_NEW_CTX)
_BASIC_META(DRM_IOCTL_RES_CTX)
_BASIC_META(DRM_IOCTL_ADD_DRAW)
_BASIC_META(DRM_IOCTL_RM_DRAW)
_BASIC_META(DRM_IOCTL_DMA)
_BASIC_META(DRM_IOCTL_LOCK)
_BASIC_META(DRM_IOCTL_UNLOCK)
_BASIC_META(DRM_IOCTL_FINISH)
_BASIC_META(DRM_IOCTL_PRIME_HANDLE_TO_FD)
_BASIC_META(DRM_IOCTL_PRIME_FD_TO_HANDLE)
_BASIC_META(DRM_IOCTL_AGP_ACQUIRE)
_BASIC_META(DRM_IOCTL_AGP_RELEASE)
// XXX: _BASIC_META(DRM_IOCTL_AGP_ENABLE)
// XXX: _BASIC_META(DRM_IOCTL_AGP_INFO)
// XXX: _BASIC_META(DRM_IOCTL_AGP_ALLOC)
// XXX: _BASIC_META(DRM_IOCTL_AGP_FREE)
// XXX: _BASIC_META(DRM_IOCTL_AGP_BIND)
// XXX: _BASIC_META(DRM_IOCTL_AGP_UNBIND)
_BASIC_META(DRM_IOCTL_SG_ALLOC)
_BASIC_META(DRM_IOCTL_SG_FREE)
_BASIC_META(DRM_IOCTL_WAIT_VBLANK)
_BASIC_META(DRM_IOCTL_CRTC_GET_SEQUENCE)
_BASIC_META(DRM_IOCTL_CRTC_QUEUE_SEQUENCE)
_BASIC_META(DRM_IOCTL_UPDATE_DRAW)
_BASIC_META(DRM_IOCTL_MODE_GETRESOURCES)
_BASIC_META(DRM_IOCTL_MODE_GETCRTC)
_BASIC_META(DRM_IOCTL_MODE_SETCRTC)
_BASIC_META(DRM_IOCTL_MODE_CURSOR)
_BASIC_META(DRM_IOCTL_MODE_GETGAMMA)
_BASIC_META(DRM_IOCTL_MODE_SETGAMMA)
_BASIC_META(DRM_IOCTL_MODE_GETENCODER)
_BASIC_META(DRM_IOCTL_MODE_GETCONNECTOR)
_BASIC_META(DRM_IOCTL_MODE_ATTACHMODE)
_BASIC_META(DRM_IOCTL_MODE_DETACHMODE)
_BASIC_META(DRM_IOCTL_MODE_GETPROPERTY)
_BASIC_META(DRM_IOCTL_MODE_SETPROPERTY)
_BASIC_META(DRM_IOCTL_MODE_GETPROPBLOB)
_BASIC_META(DRM_IOCTL_MODE_GETFB)
_BASIC_META(DRM_IOCTL_MODE_ADDFB)
_BASIC_META(DRM_IOCTL_MODE_RMFB)
_BASIC_META(DRM_IOCTL_MODE_PAGE_FLIP)
_BASIC_META(DRM_IOCTL_MODE_DIRTYFB)
_BASIC_META(DRM_IOCTL_MODE_CREATE_DUMB)
_BASIC_META(DRM_IOCTL_MODE_MAP_DUMB)
_BASIC_META(DRM_IOCTL_MODE_DESTROY_DUMB)
_BASIC_META(DRM_IOCTL_MODE_GETPLANERESOURCES)
_BASIC_META(DRM_IOCTL_MODE_GETPLANE)
_BASIC_META(DRM_IOCTL_MODE_SETPLANE)
_BASIC_META(DRM_IOCTL_MODE_ADDFB2)
_BASIC_META(DRM_IOCTL_MODE_OBJ_GETPROPERTIES)
_BASIC_META(DRM_IOCTL_MODE_OBJ_SETPROPERTY)
_BASIC_META(DRM_IOCTL_MODE_CURSOR2)
_BASIC_META(DRM_IOCTL_MODE_ATOMIC)
_BASIC_META(DRM_IOCTL_MODE_CREATEPROPBLOB)
_BASIC_META(DRM_IOCTL_MODE_DESTROYPROPBLOB)
_BASIC_META(DRM_IOCTL_SYNCOBJ_CREATE)
_BASIC_META(DRM_IOCTL_SYNCOBJ_DESTROY)
_BASIC_META(DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD)
_BASIC_META(DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE)
_BASIC_META(DRM_IOCTL_SYNCOBJ_WAIT)
_BASIC_META(DRM_IOCTL_SYNCOBJ_RESET)
_BASIC_META(DRM_IOCTL_SYNCOBJ_SIGNAL)
_BASIC_META(DRM_IOCTL_MODE_CREATE_LEASE)
_BASIC_META(DRM_IOCTL_MODE_LIST_LESSEES)
_BASIC_META(DRM_IOCTL_MODE_GET_LEASE)
_BASIC_META(DRM_IOCTL_MODE_REVOKE_LEASE)
_BASIC_META(DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT)
_BASIC_META(DRM_IOCTL_SYNCOBJ_QUERY)
_BASIC_META(DRM_IOCTL_SYNCOBJ_TRANSFER)
_BASIC_META(DRM_IOCTL_SYNCOBJ_TIMELINE_SIGNAL)
_BASIC_META(DRM_IOCTL_MODE_GETFB2)
Source/Tests/LinuxSyscalls/x64/Ioctl/ext_fs.h
+17
View File
@@ -0,0 +1,17 @@
#pragma once
#include "Tests/LinuxSyscalls/x64/Types.h"
#include "Tests/LinuxSyscalls/x64/Ioctl/HelperDefines.h"
#include <cstdint>
#include <linux/blktrace_api.h>
#include <linux/fs.h>
#include <linux/fiemap.h>
#include <sys/ioctl.h>
namespace FEX::HLE::x64 {
namespace ext_fs {
#include "Tests/LinuxSyscalls/x64/Ioctl/ext_fs.inl"
}
}
Source/Tests/LinuxSyscalls/x64/Ioctl/ext_fs.inl
+52
View File
@@ -0,0 +1,52 @@
_BASIC_META(BLKROSET)
_BASIC_META(BLKROGET)
_BASIC_META(BLKRRPART)
_BASIC_META(BLKGETSIZE)
_BASIC_META(BLKFLSBUF)
_BASIC_META(BLKRASET)
_BASIC_META(BLKRAGET)
_BASIC_META(BLKFRASET)
_BASIC_META(BLKFRAGET)
_BASIC_META(BLKSECTSET)
_BASIC_META(BLKSECTGET)
_BASIC_META(BLKSSZGET)
_BASIC_META(BLKBSZGET)
_BASIC_META(BLKBSZSET)
_BASIC_META(BLKGETSIZE64)
_BASIC_META(BLKTRACESETUP)
_BASIC_META(BLKTRACESTART)
_BASIC_META(BLKTRACESTOP)
_BASIC_META(BLKTRACETEARDOWN)
_BASIC_META(BLKDISCARD)
_BASIC_META(BLKIOMIN)
_BASIC_META(BLKIOOPT)
_BASIC_META(BLKALIGNOFF)
_BASIC_META(BLKPBSZGET)
_BASIC_META(BLKDISCARDZEROES)
_BASIC_META(BLKSECDISCARD)
_BASIC_META(BLKROTATIONAL)
_BASIC_META(BLKZEROOUT)
_BASIC_META(FIBMAP)
_BASIC_META(FIGETBSZ)
_BASIC_META(FIFREEZE)
_BASIC_META(FITHAW)
_BASIC_META(FITRIM)
_BASIC_META(FICLONE)
_BASIC_META(FICLONERANGE)
_BASIC_META(FIDEDUPERANGE)
_BASIC_META(FS_IOC_GETFLAGS)
_BASIC_META(FS_IOC_SETFLAGS)
_BASIC_META(FS_IOC_GETVERSION)
_BASIC_META(FS_IOC_SETVERSION)
_BASIC_META(FS_IOC_FIEMAP)
_BASIC_META(FS_IOC32_GETFLAGS)
_BASIC_META(FS_IOC32_SETFLAGS)
_BASIC_META(FS_IOC32_GETVERSION)
_BASIC_META(FS_IOC32_SETVERSION)
_BASIC_META(FS_IOC_FSGETXATTR)
_BASIC_META(FS_IOC_FSSETXATTR)
_BASIC_META(FS_IOC_GETFSLABEL)
_BASIC_META(FS_IOC_SETFSLABEL)
Source/Tests/LinuxSyscalls/x64/Ioctl/f2fs.h
+42
View File
@@ -0,0 +1,42 @@
#include "Tests/LinuxSyscalls/x64/Types.h"
#include "Tests/LinuxSyscalls/x64/Ioctl/HelperDefines.h"
#include <cstdint>
#include <sys/ioctl.h>
namespace FEX::HLE::x64 {
namespace f2fs {
// There is no userspace definitions for these
// Must define everything ourselves
constexpr uint32_t F2FS_IOCTL_MAGIC = 0xf5;
#define F2FS_IOC_START_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 1)
#define F2FS_IOC_COMMIT_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 2)
#define F2FS_IOC_START_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 3)
#define F2FS_IOC_RELEASE_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 4)
#define F2FS_IOC_ABORT_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 5)
#define F2FS_IOC_GARBAGE_COLLECT _IOW(F2FS_IOCTL_MAGIC, 6, uint32_t)
#define F2FS_IOC_WRITE_CHECKPOINT _IO(F2FS_IOCTL_MAGIC, 7)
//#define F2FS_IOC_DEFRAGMENT _IOWR(F2FS_IOCTL_MAGIC, 8, \
// struct f2fs_defragment)
//#define F2FS_IOC_MOVE_RANGE _IOWR(F2FS_IOCTL_MAGIC, 9, \
// struct f2fs_move_range)
//#define F2FS_IOC_FLUSH_DEVICE _IOW(F2FS_IOCTL_MAGIC, 10, \
// struct f2fs_flush_device)
//#define F2FS_IOC_GARBAGE_COLLECT_RANGE _IOW(F2FS_IOCTL_MAGIC, 11, \
// struct f2fs_gc_range)
#define F2FS_IOC_GET_FEATURES _IOR(F2FS_IOCTL_MAGIC, 12, uint32_t)
#define F2FS_IOC_SET_PIN_FILE _IOW(F2FS_IOCTL_MAGIC, 13, uint32_t)
#define F2FS_IOC_GET_PIN_FILE _IOR(F2FS_IOCTL_MAGIC, 14, uint32_t)
#define F2FS_IOC_PRECACHE_EXTENTS _IO(F2FS_IOCTL_MAGIC, 15)
#define F2FS_IOC_RESIZE_FS _IOW(F2FS_IOCTL_MAGIC, 16, uint64_t)
#define F2FS_IOC_GET_COMPRESS_BLOCKS _IOR(F2FS_IOCTL_MAGIC, 17, uint64_t)
#define F2FS_IOC_RELEASE_COMPRESS_BLOCKS \
_IOR(F2FS_IOCTL_MAGIC, 18, uint64_t)
#define F2FS_IOC_RESERVE_COMPRESS_BLOCKS \
_IOR(F2FS_IOCTL_MAGIC, 19, uint64_t)
//#define F2FS_IOC_SEC_TRIM_FILE _IOW(F2FS_IOCTL_MAGIC, 20, \
// struct f2fs_sectrim_range)
#include "Tests/LinuxSyscalls/x64/Ioctl/f2fs.inl"
}
}
Source/Tests/LinuxSyscalls/x64/Ioctl/f2fs.inl
+21
View File
@@ -0,0 +1,21 @@
_BASIC_META(F2FS_IOC_START_ATOMIC_WRITE)
_BASIC_META(F2FS_IOC_COMMIT_ATOMIC_WRITE)
_BASIC_META(F2FS_IOC_START_VOLATILE_WRITE)
_BASIC_META(F2FS_IOC_RELEASE_VOLATILE_WRITE)
_BASIC_META(F2FS_IOC_ABORT_VOLATILE_WRITE)
_BASIC_META(F2FS_IOC_GARBAGE_COLLECT)
_BASIC_META(F2FS_IOC_WRITE_CHECKPOINT)
//_CUSTOM_META(F2FS_IOC_DEFRAGMENT, XXX)
//_CUSTOM_META(F2FS_IOC_MOVE_RANGE, XXX)
//_CUSTOM_META(F2FS_IOC_FLUSH_DEVICE, XXX)
//_CUSTOM_META(F2FS_IOC_GARBAGE_COLLECT_RANGE, XXX)
_BASIC_META(F2FS_IOC_GET_FEATURES)
_BASIC_META(F2FS_IOC_SET_PIN_FILE)
_BASIC_META(F2FS_IOC_GET_PIN_FILE)
_BASIC_META(F2FS_IOC_PRECACHE_EXTENTS)
_BASIC_META(F2FS_IOC_RESIZE_FS)
_BASIC_META(F2FS_IOC_GET_COMPRESS_BLOCKS)
_BASIC_META(F2FS_IOC_RELEASE_COMPRESS_BLOCKS)
_BASIC_META(F2FS_IOC_RESERVE_COMPRESS_BLOCKS)
//_CUSTOM_META(F2FS_IOC_SEC_TRIM_FILE, XXX)
Source/Tests/LinuxSyscalls/x64/Ioctl/input.h
+12
View File
@@ -0,0 +1,12 @@
#include "Tests/LinuxSyscalls/x64/Types.h"
#include "Tests/LinuxSyscalls/x64/Ioctl/HelperDefines.h"
#include <cstdint>
#include <linux/input.h>
#include <sys/ioctl.h>
namespace FEX::HLE::x64 {
namespace input {
#include "Tests/LinuxSyscalls/x64/Ioctl/input.inl"
}
}
Source/Tests/LinuxSyscalls/x64/Ioctl/input.inl
+153
View File
@@ -0,0 +1,153 @@
_BASIC_META(EVIOCGVERSION)
_BASIC_META(EVIOCGID)
_BASIC_META(EVIOCGREP)
_BASIC_META(EVIOCSREP)
_BASIC_META(EVIOCGKEYCODE)
_BASIC_META(EVIOCGKEYCODE_V2)
_BASIC_META(EVIOCSKEYCODE)
_BASIC_META(EVIOCSKEYCODE_V2)
_BASIC_META_VAR(EVIOCGNAME, 0)
_BASIC_META_VAR(EVIOCGPHYS, 0)
_BASIC_META_VAR(EVIOCGUNIQ, 0)
_BASIC_META_VAR(EVIOCGPROP, 0)
_BASIC_META_VAR(EVIOCGMTSLOTS, 0)
_BASIC_META_VAR(EVIOCGKEY, 0)
_BASIC_META_VAR(EVIOCGLED, 0)
_BASIC_META_VAR(EVIOCGSND, 0)
_BASIC_META_VAR(EVIOCGSW, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x00, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x01, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x02, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x03, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x04, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x05, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x06, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x07, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x08, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x09, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x0A, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x0B, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x0C, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x0D, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x0E, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x0F, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x10, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x11, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x12, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x13, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x14, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x15, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x16, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x17, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x18, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x19, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x1A, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x1B, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x1C, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x1D, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x1E, 0)
_BASIC_META_VAR(EVIOCGBIT, 0x1F, 0)
_BASIC_META_VAR(EVIOCGABS, 0x00)
_BASIC_META_VAR(EVIOCGABS, 0x01)
_BASIC_META_VAR(EVIOCGABS, 0x02)
_BASIC_META_VAR(EVIOCGABS, 0x03)
_BASIC_META_VAR(EVIOCGABS, 0x04)
_BASIC_META_VAR(EVIOCGABS, 0x05)
_BASIC_META_VAR(EVIOCGABS, 0x06)
_BASIC_META_VAR(EVIOCGABS, 0x07)
_BASIC_META_VAR(EVIOCGABS, 0x08)
_BASIC_META_VAR(EVIOCGABS, 0x09)
_BASIC_META_VAR(EVIOCGABS, 0x0A)
_BASIC_META_VAR(EVIOCGABS, 0x0B)
_BASIC_META_VAR(EVIOCGABS, 0x0C)
_BASIC_META_VAR(EVIOCGABS, 0x0D)
_BASIC_META_VAR(EVIOCGABS, 0x0E)
_BASIC_META_VAR(EVIOCGABS, 0x0F)
_BASIC_META_VAR(EVIOCGABS, 0x10)
_BASIC_META_VAR(EVIOCGABS, 0x11)
_BASIC_META_VAR(EVIOCGABS, 0x12)
_BASIC_META_VAR(EVIOCGABS, 0x13)
_BASIC_META_VAR(EVIOCGABS, 0x14)
_BASIC_META_VAR(EVIOCGABS, 0x15)
_BASIC_META_VAR(EVIOCGABS, 0x16)
_BASIC_META_VAR(EVIOCGABS, 0x17)
_BASIC_META_VAR(EVIOCGABS, 0x18)
_BASIC_META_VAR(EVIOCGABS, 0x19)
_BASIC_META_VAR(EVIOCGABS, 0x1A)
_BASIC_META_VAR(EVIOCGABS, 0x1B)
_BASIC_META_VAR(EVIOCGABS, 0x1C)
_BASIC_META_VAR(EVIOCGABS, 0x1D)
_BASIC_META_VAR(EVIOCGABS, 0x1E)
_BASIC_META_VAR(EVIOCGABS, 0x1F)
_BASIC_META_VAR(EVIOCGABS, 0x20)
_BASIC_META_VAR(EVIOCGABS, 0x21)
_BASIC_META_VAR(EVIOCGABS, 0x22)
_BASIC_META_VAR(EVIOCGABS, 0x23)
_BASIC_META_VAR(EVIOCGABS, 0x24)
_BASIC_META_VAR(EVIOCGABS, 0x25)
_BASIC_META_VAR(EVIOCGABS, 0x26)
_BASIC_META_VAR(EVIOCGABS, 0x27)
_BASIC_META_VAR(EVIOCGABS, 0x28)
_BASIC_META_VAR(EVIOCGABS, 0x29)
_BASIC_META_VAR(EVIOCGABS, 0x2A)
_BASIC_META_VAR(EVIOCGABS, 0x2B)
_BASIC_META_VAR(EVIOCGABS, 0x2C)
_BASIC_META_VAR(EVIOCGABS, 0x2D)
_BASIC_META_VAR(EVIOCGABS, 0x2E)
_BASIC_META_VAR(EVIOCGABS, 0x2F)
_BASIC_META_VAR(EVIOCSABS, 0x00)
_BASIC_META_VAR(EVIOCSABS, 0x01)
_BASIC_META_VAR(EVIOCSABS, 0x02)
_BASIC_META_VAR(EVIOCSABS, 0x03)
_BASIC_META_VAR(EVIOCSABS, 0x04)
_BASIC_META_VAR(EVIOCSABS, 0x05)
_BASIC_META_VAR(EVIOCSABS, 0x06)
_BASIC_META_VAR(EVIOCSABS, 0x07)
_BASIC_META_VAR(EVIOCSABS, 0x08)
_BASIC_META_VAR(EVIOCSABS, 0x09)
_BASIC_META_VAR(EVIOCSABS, 0x0A)
_BASIC_META_VAR(EVIOCSABS, 0x0B)
_BASIC_META_VAR(EVIOCSABS, 0x0C)
_BASIC_META_VAR(EVIOCSABS, 0x0D)
_BASIC_META_VAR(EVIOCSABS, 0x0E)
_BASIC_META_VAR(EVIOCSABS, 0x0F)
_BASIC_META_VAR(EVIOCSABS, 0x10)
_BASIC_META_VAR(EVIOCSABS, 0x11)
_BASIC_META_VAR(EVIOCSABS, 0x12)
_BASIC_META_VAR(EVIOCSABS, 0x13)
_BASIC_META_VAR(EVIOCSABS, 0x14)
_BASIC_META_VAR(EVIOCSABS, 0x15)
_BASIC_META_VAR(EVIOCSABS, 0x16)
_BASIC_META_VAR(EVIOCSABS, 0x17)
_BASIC_META_VAR(EVIOCSABS, 0x18)
_BASIC_META_VAR(EVIOCSABS, 0x19)
_BASIC_META_VAR(EVIOCSABS, 0x1A)
_BASIC_META_VAR(EVIOCSABS, 0x1B)
_BASIC_META_VAR(EVIOCSABS, 0x1C)
_BASIC_META_VAR(EVIOCSABS, 0x1D)
_BASIC_META_VAR(EVIOCSABS, 0x1E)
_BASIC_META_VAR(EVIOCSABS, 0x1F)
_BASIC_META_VAR(EVIOCSABS, 0x20)
_BASIC_META_VAR(EVIOCSABS, 0x21)
_BASIC_META_VAR(EVIOCSABS, 0x22)
_BASIC_META_VAR(EVIOCSABS, 0x23)
_BASIC_META_VAR(EVIOCSABS, 0x24)
_BASIC_META_VAR(EVIOCSABS, 0x25)
_BASIC_META_VAR(EVIOCSABS, 0x26)
_BASIC_META_VAR(EVIOCSABS, 0x27)
_BASIC_META_VAR(EVIOCSABS, 0x28)
_BASIC_META_VAR(EVIOCSABS, 0x29)
_BASIC_META_VAR(EVIOCSABS, 0x2A)
_BASIC_META_VAR(EVIOCSABS, 0x2B)
_BASIC_META_VAR(EVIOCSABS, 0x2C)
_BASIC_META_VAR(EVIOCSABS, 0x2D)
_BASIC_META_VAR(EVIOCSABS, 0x2E)
_BASIC_META_VAR(EVIOCSABS, 0x2F)
// XXX: _BASIC_META(EVIOCSFF)
_BASIC_META(EVIOCRMFF)
_BASIC_META(EVIOCGEFFECTS)
_BASIC_META(EVIOCGRAB)
_BASIC_META(EVIOCREVOKE)
_BASIC_META(EVIOCGMASK)
_BASIC_META(EVIOCSMASK)
_BASIC_META(EVIOCSCLOCKID)
Source/Tests/LinuxSyscalls/x64/Ioctl/joystick.h
+15
View File
@@ -0,0 +1,15 @@
#pragma once
#include "Tests/LinuxSyscalls/x64/Types.h"
#include "Tests/LinuxSyscalls/x64/Ioctl/HelperDefines.h"
#include <cstdint>
#include <linux/joystick.h>
#include <sys/ioctl.h>
namespace FEX::HLE::x64 {
namespace joystick {
#include "Tests/LinuxSyscalls/x64/Ioctl/joystick.inl"
}
}
Source/Tests/LinuxSyscalls/x64/Ioctl/joystick.inl
+10
View File
@@ -0,0 +1,10 @@
_BASIC_META(JSIOCGVERSION)
_BASIC_META(JSIOCGAXES)
_BASIC_META(JSIOCGBUTTONS)
_BASIC_META_VAR(JSIOCGNAME, 0)
_BASIC_META(JSIOCSCORR)
_BASIC_META(JSIOCGCORR)
_BASIC_META(JSIOCSAXMAP)
_BASIC_META(JSIOCGAXMAP)
_BASIC_META(JSIOCSBTNMAP)
_BASIC_META(JSIOCGBTNMAP)
Source/Tests/LinuxSyscalls/x64/Ioctl/msdos_fs.h
+15
View File
@@ -0,0 +1,15 @@
#pragma once
#include "Tests/LinuxSyscalls/x64/Types.h"
#include "Tests/LinuxSyscalls/x64/Ioctl/HelperDefines.h"
#include <cstdint>
#include <linux/msdos_fs.h>
#include <sys/ioctl.h>
namespace FEX::HLE::x64 {
namespace msdos_fs {
#include "Tests/LinuxSyscalls/x64/Ioctl/msdos_fs.inl"
}
}
Source/Tests/LinuxSyscalls/x64/Ioctl/msdos_fs.inl
+5
View File
@@ -0,0 +1,5 @@
_BASIC_META(VFAT_IOCTL_READDIR_BOTH)
_BASIC_META(VFAT_IOCTL_READDIR_SHORT)
_BASIC_META(FAT_IOCTL_GET_ATTRIBUTES)
_BASIC_META(FAT_IOCTL_SET_ATTRIBUTES)
_BASIC_META(FAT_IOCTL_GET_VOLUME_ID)
Source/Tests/LinuxSyscalls/x64/Ioctl/msm_drm.inl
+12
View File
@@ -0,0 +1,12 @@
_BASIC_META(DRM_IOCTL_MSM_GET_PARAM)
_BASIC_META(DRM_IOCTL_MSM_GEM_NEW)
_BASIC_META(DRM_IOCTL_MSM_GEM_INFO)
_BASIC_META(DRM_IOCTL_MSM_GEM_CPU_PREP)
_BASIC_META(DRM_IOCTL_MSM_GEM_CPU_FINI)
_BASIC_META(DRM_IOCTL_MSM_GEM_SUBMIT)
_BASIC_META(DRM_IOCTL_MSM_WAIT_FENCE)
_BASIC_META(DRM_IOCTL_MSM_GEM_MADVISE)
_BASIC_META(DRM_IOCTL_MSM_SUBMITQUEUE_NEW)
_BASIC_META(DRM_IOCTL_MSM_SUBMITQUEUE_CLOSE)
_BASIC_META(DRM_IOCTL_MSM_SUBMITQUEUE_QUERY)
Source/Tests/LinuxSyscalls/x64/Ioctl/sockios.h
+14
View File
@@ -0,0 +1,14 @@
#include "Tests/LinuxSyscalls/x64/Types.h"
#include "Tests/LinuxSyscalls/x64/Ioctl/HelperDefines.h"
#include <cstdint>
#include <linux/if.h>
#include <linux/sockios.h>
#include <sys/ioctl.h>
namespace FEX::HLE::x64 {
namespace sockios {
#include "Tests/LinuxSyscalls/x64/Ioctl/sockios.inl"
}
}
Source/Tests/LinuxSyscalls/x64/Ioctl/sockios.inl
+119
View File
@@ -0,0 +1,119 @@
#ifndef SIOCGSTAMP_OLD
#define SIOCGSTAMP_OLD 0x8906
#endif
_BASIC_META(SIOCGSTAMP_OLD)
#ifndef SIOCGSTAMPNS_OLD
#define SIOCGSTAMPNS_OLD 0x8907
#endif
_BASIC_META(SIOCGSTAMPNS_OLD)
_BASIC_META(SIOCADDRT)
_BASIC_META(SIOCDELRT)
_BASIC_META(SIOCRTMSG)
_BASIC_META(SIOCGIFNAME)
_BASIC_META(SIOCSIFLINK)
_CUSTOM_META(SIOCGIFCONF,
_IOC(
_IOC_DIR(SIOCGIFCONF),
_IOC_TYPE(SIOCGIFCONF),
_IOC_NR(SIOCGIFCONF),
sizeof(struct ifconf))) // This should hit failure
_BASIC_META(SIOCGIFFLAGS)
_BASIC_META(SIOCSIFFLAGS)
_BASIC_META(SIOCGIFADDR)
_BASIC_META(SIOCSIFADDR)
_BASIC_META(SIOCGIFDSTADDR)
_BASIC_META(SIOCSIFDSTADDR)
_BASIC_META(SIOCGIFBRDADDR)
_BASIC_META(SIOCSIFBRDADDR)
_BASIC_META(SIOCGIFNETMASK)
_BASIC_META(SIOCSIFNETMASK)
_BASIC_META(SIOCGIFMETRIC)
_BASIC_META(SIOCSIFMETRIC)
_BASIC_META(SIOCGIFMEM)
_BASIC_META(SIOCSIFMEM)
_BASIC_META(SIOCGIFMTU)
_BASIC_META(SIOCSIFMTU)
_BASIC_META(SIOCSIFNAME)
_BASIC_META(SIOCSIFHWADDR)
_BASIC_META(SIOCGIFENCAP)
_BASIC_META(SIOCSIFENCAP)
_BASIC_META(SIOCGIFHWADDR)
_BASIC_META(SIOCGIFSLAVE)
_BASIC_META(SIOCSIFSLAVE)
_BASIC_META(SIOCADDMULTI)
_BASIC_META(SIOCDELMULTI)
_BASIC_META(SIOCGIFINDEX)
_BASIC_META(SIOCSIFPFLAGS)
_BASIC_META(SIOCGIFPFLAGS)
_BASIC_META(SIOCDIFADDR)
_BASIC_META(SIOCSIFHWBROADCAST)
_BASIC_META(SIOCGIFCOUNT)
_BASIC_META(SIOCGIFBR)
_BASIC_META(SIOCSIFBR)
_BASIC_META(SIOCGIFTXQLEN)
_BASIC_META(SIOCSIFTXQLEN)
_BASIC_META(SIOCETHTOOL)
_BASIC_META(SIOCGMIIPHY)
_BASIC_META(SIOCGMIIREG)
_BASIC_META(SIOCSMIIREG)
_BASIC_META(SIOCWANDEV)
_BASIC_META(SIOCOUTQNSD)
_BASIC_META(SIOCGSKNS)
_BASIC_META(SIOCDARP)
_BASIC_META(SIOCGARP)
_BASIC_META(SIOCSARP)
_BASIC_META(SIOCDRARP)
_BASIC_META(SIOCGRARP)
_BASIC_META(SIOCSRARP)
_BASIC_META(SIOCGIFMAP)
_BASIC_META(SIOCSIFMAP)
_BASIC_META(SIOCADDDLCI)
_BASIC_META(SIOCDELDLCI)
_BASIC_META(SIOCGIFVLAN)
_BASIC_META(SIOCSIFVLAN)
_BASIC_META(SIOCBONDENSLAVE)
_BASIC_META(SIOCBONDRELEASE)
_BASIC_META(SIOCBONDSETHWADDR)
_BASIC_META(SIOCBONDSLAVEINFOQUERY)
_BASIC_META(SIOCBONDINFOQUERY)
_BASIC_META(SIOCBONDCHANGEACTIVE)
_BASIC_META(SIOCBRADDBR)
_BASIC_META(SIOCBRDELBR)
_BASIC_META(SIOCBRADDIF)
_BASIC_META(SIOCBRDELIF)
_BASIC_META(SIOCSHWTSTAMP)
_BASIC_META(SIOCGHWTSTAMP)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE, SIOCDEVPRIVATE, 0x0)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE_1, SIOCDEVPRIVATE, 0x1)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE_2, SIOCDEVPRIVATE, 0x2)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE_3, SIOCDEVPRIVATE, 0x3)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE_4, SIOCDEVPRIVATE, 0x4)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE_5, SIOCDEVPRIVATE, 0x5)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE_6, SIOCDEVPRIVATE, 0x6)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE_7, SIOCDEVPRIVATE, 0x7)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE_8, SIOCDEVPRIVATE, 0x8)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE_9, SIOCDEVPRIVATE, 0x9)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE_A, SIOCDEVPRIVATE, 0xA)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE_B, SIOCDEVPRIVATE, 0xB)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE_C, SIOCDEVPRIVATE, 0xC)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE_D, SIOCDEVPRIVATE, 0xD)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE_E, SIOCDEVPRIVATE, 0xE)
_CUSTOM_META_OFFSET(SIOCDEVPRIVATE_F, SIOCDEVPRIVATE, 0xF)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE, SIOCPROTOPRIVATE, 0x0)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE_1, SIOCPROTOPRIVATE, 0x1)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE_2, SIOCPROTOPRIVATE, 0x2)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE_3, SIOCPROTOPRIVATE, 0x3)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE_4, SIOCPROTOPRIVATE, 0x4)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE_5, SIOCPROTOPRIVATE, 0x5)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE_6, SIOCPROTOPRIVATE, 0x6)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE_7, SIOCPROTOPRIVATE, 0x7)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE_8, SIOCPROTOPRIVATE, 0x8)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE_9, SIOCPROTOPRIVATE, 0x9)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE_A, SIOCPROTOPRIVATE, 0xA)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE_B, SIOCPROTOPRIVATE, 0xB)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE_C, SIOCPROTOPRIVATE, 0xC)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE_D, SIOCPROTOPRIVATE, 0xD)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE_E, SIOCPROTOPRIVATE, 0xE)
_CUSTOM_META_OFFSET(SIOCPROTOPRIVATE_F, SIOCPROTOPRIVATE, 0xF)
Source/Tests/LinuxSyscalls/x64/Ioctl/wireless.h
+13
View File
@@ -0,0 +1,13 @@
#include "Tests/LinuxSyscalls/x64/Types.h"
#include "Tests/LinuxSyscalls/x64/Ioctl/HelperDefines.h"
#include <cstdint>
#include <linux/wireless.h>
#include <sys/ioctl.h>
namespace FEX::HLE::x64 {
namespace wireless {
#include "Tests/LinuxSyscalls/x64/Ioctl/wireless.inl"
}
}
Source/Tests/LinuxSyscalls/x64/Ioctl/wireless.inl
+55
View File
@@ -0,0 +1,55 @@
_BASIC_META(SIOCSIWCOMMIT)
_BASIC_META(SIOCGIWNAME)
_BASIC_META(SIOCSIWNWID)
_BASIC_META(SIOCGIWNWID)
_BASIC_META(SIOCSIWFREQ)
_BASIC_META(SIOCGIWFREQ)
_BASIC_META(SIOCSIWMODE)
_BASIC_META(SIOCGIWMODE)
_BASIC_META(SIOCSIWSENS)
_BASIC_META(SIOCGIWSENS)
_BASIC_META(SIOCSIWRANGE)
_BASIC_META(SIOCGIWRANGE)
_BASIC_META(SIOCSIWPRIV)
_BASIC_META(SIOCGIWPRIV)
_BASIC_META(SIOCSIWSTATS)
_BASIC_META(SIOCGIWSTATS)
_BASIC_META(SIOCSIWSPY)
_BASIC_META(SIOCGIWSPY)
_BASIC_META(SIOCSIWTHRSPY)
_BASIC_META(SIOCGIWTHRSPY)
_BASIC_META(SIOCSIWAP)
_BASIC_META(SIOCGIWAP)
_BASIC_META(SIOCGIWAPLIST)
_BASIC_META(SIOCSIWSCAN)
_BASIC_META(SIOCGIWSCAN)
_BASIC_META(SIOCSIWESSID)
_BASIC_META(SIOCGIWESSID)
_BASIC_META(SIOCSIWNICKN)
_BASIC_META(SIOCGIWNICKN)
_BASIC_META(SIOCSIWRATE)
_BASIC_META(SIOCGIWRATE)
_BASIC_META(SIOCSIWRTS)
_BASIC_META(SIOCGIWRTS)
_BASIC_META(SIOCSIWFRAG)
_BASIC_META(SIOCGIWFRAG)
_BASIC_META(SIOCSIWTXPOW)
_BASIC_META(SIOCGIWTXPOW)
_BASIC_META(SIOCSIWRETRY)
_BASIC_META(SIOCGIWRETRY)
_BASIC_META(SIOCSIWENCODE)
_BASIC_META(SIOCGIWENCODE)
_BASIC_META(SIOCSIWPOWER)
_BASIC_META(SIOCGIWPOWER)
_BASIC_META(SIOCSIWGENIE)
_BASIC_META(SIOCGIWGENIE)
_BASIC_META(SIOCSIWMLME)
_BASIC_META(SIOCSIWAUTH)
_BASIC_META(SIOCGIWAUTH)
_BASIC_META(SIOCSIWENCODEEXT)
_BASIC_META(SIOCGIWENCODEEXT)
_BASIC_META(SIOCSIWPMKSA)
_BASIC_META(SIOCIWFIRSTPRIV)
_BASIC_META(SIOCIWLASTPRIV)
Source/Tests/LinuxSyscalls/x64/Memory.cpp
+9 -9
View File
@@ -33,7 +33,7 @@ namespace FEX::HLE::x64 {
void RegisterMemory(FEX::HLE::SyscallHandler *const Handler) {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_X64_FLAGS(munmap, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_X64_FLAGS(munmap, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, void *addr, size_t length) -> uint64_t {
uint64_t Result{};
if (addr < (void*)0x1'0000'0000ULL) {
@@ -58,7 +58,7 @@ namespace FEX::HLE::x64 {
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_X64_FLAGS(mmap, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_X64_FLAGS(mmap, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, void *addr, size_t length, int prot, int flags, int fd, off_t offset) -> uint64_t {
static FEX_CONFIG_OPT(AOTIRLoad, AOTIRLOAD);
@@ -90,13 +90,13 @@ namespace FEX::HLE::x64 {
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(mremap, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(mremap, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, void *old_address, size_t old_size, size_t new_size, int flags, void *new_address) -> uint64_t {
uint64_t Result = reinterpret_cast<uint64_t>(::mremap(old_address, old_size, new_size, flags, new_address));
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_X64_FLAGS(mprotect, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_X64_FLAGS(mprotect, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, void *addr, size_t len, int prot) -> uint64_t {
uint64_t Result = ::mprotect(addr, len, prot);
@@ -107,32 +107,32 @@ namespace FEX::HLE::x64 {
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(mlockall, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(mlockall, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int flags) -> uint64_t {
uint64_t Result = ::mlockall(flags);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(munlockall, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(munlockall, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame) -> uint64_t {
uint64_t Result = ::munlockall();
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(shmat, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(shmat, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int shmid, const void *shmaddr, int shmflg) -> uint64_t {
uint64_t Result = reinterpret_cast<uint64_t>(shmat(shmid, shmaddr, shmflg));
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(shmdt, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(shmdt, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, const void *shmaddr) -> uint64_t {
uint64_t Result = ::shmdt(shmaddr);
SYSCALL_ERRNO();
});
if (Handler->IsHostKernelVersionAtLeast(5, 10, 0)) {
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(process_madvise, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(process_madvise, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int pidfd, const struct iovec *iovec, size_t vlen, int advice, unsigned int flags) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(process_madvise), pidfd, iovec, vlen, advice, flags);
SYSCALL_ERRNO();
Source/Tests/LinuxSyscalls/x64/Syscalls.cpp
+3 -3
View File
@@ -48,7 +48,7 @@ namespace FEX::HLE::x64 {
void* SyscallHandler;
int ArgumentCount;
int32_t HostSyscallNumber;
uint8_t Flags;
FEXCore::IR::SyscallFlags Flags;
#ifdef DEBUG_STRACE
std::string TraceFormatString;
#endif
@@ -58,7 +58,7 @@ namespace FEX::HLE::x64 {
void RegisterSyscallInternal(int SyscallNumber,
int32_t HostSyscallNumber,
uint8_t Flags,
FEXCore::IR::SyscallFlags Flags,
#ifdef DEBUG_STRACE
const std::string& TraceFormatString,
#endif
@@ -170,7 +170,7 @@ namespace FEX::HLE::x64 {
auto &Def = Definitions.at(SyscallNumber);
Def.Ptr = cvt(&UnimplementedSyscallSafe);
Def.NumArgs = 0;
Def.Flags = FEXCore::IR::SYSCALL_FLAG_DEFAULT;
Def.Flags = FEXCore::IR::SyscallFlags::DEFAULT;
// This will allow our syscall optimization code to make this code more optimal
// Unlikely to hit a hot path though
Def.HostSyscallNumber = SYSCALL_DEF(MAX);
Source/Tests/LinuxSyscalls/x64/Syscalls.h
+6 -7
View File
@@ -32,7 +32,7 @@ std::unique_ptr<FEX::HLE::SyscallHandler> CreateHandler(FEXCore::Context::Contex
void RegisterSyscallInternal(int SyscallNumber,
int32_t HostSyscallNumber,
uint8_t Flags,
FEXCore::IR::SyscallFlags Flags,
#ifdef DEBUG_STRACE
const std::string& TraceFormatString,
#endif
@@ -48,7 +48,7 @@ void RegisterSyscallInternal(int SyscallNumber,
// Deduces return, args... from the function passed
// Does not work with lambas, because they are objects with operator (), not functions
template<typename R, typename ...Args>
bool RegisterSyscall(int SyscallNumber, int32_t HostSyscallNumber, uint8_t Flags, const char *Name, R(*fn)(FEXCore::Core::CpuStateFrame *Frame, Args...)) {
void RegisterSyscall(int SyscallNumber, int32_t HostSyscallNumber, FEXCore::IR::SyscallFlags Flags, const char *Name, R(*fn)(FEXCore::Core::CpuStateFrame *Frame, Args...)) {
#ifdef DEBUG_STRACE
auto TraceFormatString = std::string(Name) + "(" + CollectArgsFmtString<Args...>() + ") = %ld";
#endif
@@ -59,7 +59,6 @@ bool RegisterSyscall(int SyscallNumber, int32_t HostSyscallNumber, uint8_t Flags
TraceFormatString,
#endif
reinterpret_cast<void*>(fn), sizeof...(Args));
return true;
}
//LambdaTraits extracts the function singature of a lambda from operator()
@@ -76,9 +75,9 @@ struct LambdaTraits<T (C::*)(Args...) const>
// Non-capturing lambdas can be cast to function pointers, but this does not happen on argument matching
// This is some glue logic that will cast a lambda and call the base RegisterSyscall implementation
template<class F>
bool RegisterSyscall(int num, int32_t HostSyscallNumber, uint8_t Flags, const char *name, F f){
void RegisterSyscall(int num, int32_t HostSyscallNumber, FEXCore::IR::SyscallFlags Flags, const char *name, F f){
typedef typename LambdaTraits<decltype(&F::operator())>::Type Signature;
return RegisterSyscall(num, HostSyscallNumber, Flags, name, (Signature)f);
RegisterSyscall(num, HostSyscallNumber, Flags, name, (Signature)f);
}
}
@@ -88,14 +87,14 @@ bool RegisterSyscall(int num, int32_t HostSyscallNumber, uint8_t Flags, const ch
struct impl_##name { \
impl_##name() \
{ \
FEX::HLE::x64::RegisterSyscall(x64::SYSCALL_x64_##name, ~0, FEXCore::IR::SYSCALL_FLAG_DEFAULT, #name, lambda); \
FEX::HLE::x64::RegisterSyscall(x64::SYSCALL_x64_##name, ~0, FEXCore::IR::SyscallFlags::DEFAULT, #name, lambda); \
} } impl_##name
#define REGISTER_SYSCALL_IMPL_X64_PASS(name, lambda) \
struct impl_##name { \
impl_##name() \
{ \
FEX::HLE::x64::RegisterSyscall(x64::SYSCALL_x64_##name, SYSCALL_DEF(name), FEXCore::IR::SYSCALL_FLAG_DEFAULT, #name, lambda); \
FEX::HLE::x64::RegisterSyscall(x64::SYSCALL_x64_##name, SYSCALL_DEF(name), FEXCore::IR::SyscallFlags::DEFAULT, #name, lambda); \
} } impl_##name
#define REGISTER_SYSCALL_IMPL_X64_FLAGS(name, flags, lambda) \
Source/Tests/LinuxSyscalls/x64/Thread.cpp
+8 -8
View File
@@ -35,7 +35,7 @@ namespace FEX::HLE::x64 {
void RegisterThread() {
using namespace FEXCore::IR;
REGISTER_SYSCALL_IMPL_X64_FLAGS(clone, SYSCALL_FLAG_DEFAULT,
REGISTER_SYSCALL_IMPL_X64_FLAGS(clone, SyscallFlags::DEFAULT,
([](FEXCore::Core::CpuStateFrame *Frame, uint32_t flags, void *stack, pid_t *parent_tid, pid_t *child_tid, void *tls) -> uint64_t {
FEX::HLE::clone3_args args {
.Type = TypeOfClone::TYPE_CLONE2,
@@ -56,7 +56,7 @@ namespace FEX::HLE::x64 {
return CloneHandler(Frame, &args);
}));
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(futex, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(futex, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int *uaddr, int futex_op, int val, const struct timespec *timeout, int *uaddr2, uint32_t val3) -> uint64_t {
uint64_t Result = syscall(SYSCALL_DEF(futex),
uaddr,
@@ -68,7 +68,7 @@ namespace FEX::HLE::x64 {
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_X64_FLAGS(set_robust_list, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_X64_FLAGS(set_robust_list, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, struct robust_list_head *head, size_t len) -> uint64_t {
auto Thread = Frame->Thread;
Thread->ThreadManager.robust_list_head = reinterpret_cast<uint64_t>(head);
@@ -76,7 +76,7 @@ namespace FEX::HLE::x64 {
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(get_robust_list, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(get_robust_list, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int pid, struct robust_list_head **head, size_t *len_ptr) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(get_robust_list), pid, head, len_ptr);
SYSCALL_ERRNO();
@@ -88,7 +88,7 @@ namespace FEX::HLE::x64 {
// launch a new process under fex
// currently does not propagate argv[0] correctly
REGISTER_SYSCALL_IMPL_X64_FLAGS(execve, SYSCALL_FLAG_DEFAULT,
REGISTER_SYSCALL_IMPL_X64_FLAGS(execve, SyscallFlags::DEFAULT,
[](FEXCore::Core::CpuStateFrame *Frame, const char *pathname, char *const argv[], char *const envp[]) -> uint64_t {
std::vector<const char*> Args;
std::vector<const char*> Envp;
@@ -114,7 +114,7 @@ namespace FEX::HLE::x64 {
return FEX::HLE::ExecveHandler(pathname, ArgsPtr, EnvpPtr, nullptr);
});
REGISTER_SYSCALL_IMPL_X64_FLAGS(execveat, SYSCALL_FLAG_DEFAULT,
REGISTER_SYSCALL_IMPL_X64_FLAGS(execveat, SyscallFlags::DEFAULT,
([](FEXCore::Core::CpuStateFrame *Frame, int dirfd, const char *pathname, char *const argv[], char *const envp[], int flags) -> uint64_t {
std::vector<const char*> Args;
std::vector<const char*> Envp;
@@ -145,13 +145,13 @@ namespace FEX::HLE::x64 {
return FEX::HLE::ExecveHandler(pathname, ArgsPtr, EnvpPtr, &AtArgs);
}));
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(wait4, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(wait4, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, pid_t pid, int *wstatus, int options, struct rusage *rusage) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(wait4), pid, wstatus, options, rusage);
SYSCALL_ERRNO();
});
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(waitid, SYSCALL_FLAG_OPTIMIZETHROUGH | SYSCALL_FLAG_NOSYNCSTATEONENTRY,
REGISTER_SYSCALL_IMPL_X64_PASS_FLAGS(waitid, SyscallFlags::OPTIMIZETHROUGH | SyscallFlags::NOSYNCSTATEONENTRY,
[](FEXCore::Core::CpuStateFrame *Frame, int which, pid_t upid, siginfo_t *infop, int options, struct rusage *rusage) -> uint64_t {
uint64_t Result = ::syscall(SYSCALL_DEF(waitid), which, upid, infop, options, rusage);
SYSCALL_ERRNO();