diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/EPoll.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/EPoll.cpp index dc48d28623..27b03e9769 100644 --- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/EPoll.cpp +++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/EPoll.cpp @@ -16,12 +16,12 @@ tags: LinuxSyscalls|syscalls-shared #include namespace FEX::HLE { +auto epoll_create(FEXCore::Core::CpuStateFrame* Frame, int size) -> uint64_t { + uint64_t Result = ::epoll_create(size); + SYSCALL_ERRNO(); +} void RegisterEpoll(FEX::HLE::SyscallHandler* Handler) { using namespace FEXCore::IR; - - REGISTER_SYSCALL_IMPL(epoll_create, [](FEXCore::Core::CpuStateFrame* Frame, int size) -> uint64_t { - uint64_t Result = epoll_create(size); - SYSCALL_ERRNO(); - }); + REGISTER_SYSCALL_IMPL(epoll_create, epoll_create); } } // namespace FEX::HLE diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FD.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FD.cpp index a137c43dcf..11bc3e114a 100644 --- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FD.cpp +++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FD.cpp @@ -29,112 +29,129 @@ tags: LinuxSyscalls|syscalls-shared #include namespace FEX::HLE { +auto poll(FEXCore::Core::CpuStateFrame* Frame, struct pollfd* fds, nfds_t nfds, int timeout) -> uint64_t { + if (nfds) { + // fds is allowed to be garbage if nfds is zero. + FaultSafeUserMemAccess::VerifyIsWritable(fds, sizeof(struct pollfd) * nfds); + } + uint64_t Result = ::poll(fds, nfds, timeout); + SYSCALL_ERRNO(); +} + +auto open(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(); +} + +auto close(FEXCore::Core::CpuStateFrame* Frame, int fd) -> uint64_t { + uint64_t Result = FEX::HLE::_SyscallHandler->FM.Close(fd); + SYSCALL_ERRNO(); +} + +auto chown(FEXCore::Core::CpuStateFrame* Frame, const char* pathname, uid_t owner, gid_t group) -> uint64_t { + uint64_t Result = ::chown(pathname, owner, group); + SYSCALL_ERRNO(); +} + +auto lchown(FEXCore::Core::CpuStateFrame* Frame, const char* pathname, uid_t owner, gid_t group) -> uint64_t { + uint64_t Result = ::lchown(pathname, owner, group); + SYSCALL_ERRNO(); +} + +auto access(FEXCore::Core::CpuStateFrame* Frame, const char* pathname, int mode) -> uint64_t { + uint64_t Result = FEX::HLE::_SyscallHandler->FM.Access(pathname, mode); + SYSCALL_ERRNO(); +} + +auto pipe(FEXCore::Core::CpuStateFrame* Frame, int pipefd[2]) -> uint64_t { + uint64_t Result = ::pipe(pipefd); + SYSCALL_ERRNO(); +} + +auto dup3(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(); +} + +auto inotify_init(FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { + uint64_t Result = ::inotify_init(); + SYSCALL_ERRNO(); +} + +auto openat(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(); +} + +auto readlinkat(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(); +} + +auto faccessat(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(); +} + +auto faccessat2(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(); +} + +auto openat2(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); + memcpy(&HostHow, how, HostSize); + + HostHow.flags = FEX::HLE::RemapFromX86Flags(HostHow.flags); + uint64_t Result = FEX::HLE::_SyscallHandler->FM.Openat2(dirfs, pathname, &HostHow, HostSize); + SYSCALL_ERRNO(); +} + +auto eventfd(FEXCore::Core::CpuStateFrame* Frame, uint32_t count) -> uint64_t { + uint64_t Result = ::syscall(SYSCALL_DEF(eventfd2), count, 0); + SYSCALL_ERRNO(); +} + +auto pipe2(FEXCore::Core::CpuStateFrame* Frame, int pipefd[2], int flags) -> uint64_t { + flags = FEX::HLE::RemapFromX86Flags(flags); + uint64_t Result = ::pipe2(pipefd, flags); + SYSCALL_ERRNO(); +} + +auto statx(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(); +} + +auto close_range(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(); +} + void RegisterFD(FEX::HLE::SyscallHandler* Handler) { using namespace FEXCore::IR; - REGISTER_SYSCALL_IMPL(poll, [](FEXCore::Core::CpuStateFrame* Frame, struct pollfd* fds, nfds_t nfds, int timeout) -> uint64_t { - if (nfds) { - // fds is allowed to be garbage if nfds is zero. - FaultSafeUserMemAccess::VerifyIsWritable(fds, sizeof(struct pollfd) * nfds); - } - uint64_t Result = ::poll(fds, nfds, timeout); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(open, [](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(close, [](FEXCore::Core::CpuStateFrame* Frame, int fd) -> uint64_t { - uint64_t Result = FEX::HLE::_SyscallHandler->FM.Close(fd); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(chown, [](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(lchown, [](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(access, [](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(pipe, [](FEXCore::Core::CpuStateFrame* Frame, int pipefd[2]) -> uint64_t { - uint64_t Result = ::pipe(pipefd); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(dup3, [](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(inotify_init, [](FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { - uint64_t Result = ::inotify_init(); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(openat, [](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(readlinkat, [](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(faccessat, [](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(); - }); - - REGISTER_SYSCALL_IMPL(faccessat2, [](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( - openat2, [](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); - memcpy(&HostHow, how, HostSize); - - HostHow.flags = FEX::HLE::RemapFromX86Flags(HostHow.flags); - uint64_t Result = FEX::HLE::_SyscallHandler->FM.Openat2(dirfs, pathname, &HostHow, HostSize); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(eventfd, [](FEXCore::Core::CpuStateFrame* Frame, uint32_t count) -> uint64_t { - uint64_t Result = ::syscall(SYSCALL_DEF(eventfd2), count, 0); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(pipe2, [](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( - statx, [](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(close_range, [](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(); - }); + REGISTER_SYSCALL_IMPL(poll, poll); + REGISTER_SYSCALL_IMPL(open, open); + REGISTER_SYSCALL_IMPL(close, close); + REGISTER_SYSCALL_IMPL(chown, chown); + REGISTER_SYSCALL_IMPL(lchown, lchown); + REGISTER_SYSCALL_IMPL(access, access); + REGISTER_SYSCALL_IMPL(pipe, pipe); + REGISTER_SYSCALL_IMPL(dup3, dup3); + REGISTER_SYSCALL_IMPL(inotify_init, inotify_init); + REGISTER_SYSCALL_IMPL(openat, openat); + REGISTER_SYSCALL_IMPL(readlinkat, readlinkat); + REGISTER_SYSCALL_IMPL(faccessat, faccessat); + REGISTER_SYSCALL_IMPL(faccessat2, faccessat2); + REGISTER_SYSCALL_IMPL(openat2, openat2); + REGISTER_SYSCALL_IMPL(eventfd, eventfd); + REGISTER_SYSCALL_IMPL(pipe2, pipe2); + REGISTER_SYSCALL_IMPL(statx, statx); + REGISTER_SYSCALL_IMPL(close_range, close_range); } } // namespace FEX::HLE diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FS.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FS.cpp index 98fe3d35c2..39a0d50f44 100644 --- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FS.cpp +++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/FS.cpp @@ -22,129 +22,155 @@ tags: LinuxSyscalls|syscalls-shared #include namespace FEX::HLE { +using namespace FEXCore::IR; + +auto rename(FEXCore::Core::CpuStateFrame* Frame, const char* oldpath, const char* newpath) -> uint64_t { + uint64_t Result = ::rename(oldpath, newpath); + SYSCALL_ERRNO(); +} + +auto mkdir(FEXCore::Core::CpuStateFrame* Frame, const char* pathname, mode_t mode) -> uint64_t { + uint64_t Result = ::mkdir(pathname, mode); + SYSCALL_ERRNO(); +} + +auto rmdir(FEXCore::Core::CpuStateFrame* Frame, const char* pathname) -> uint64_t { + uint64_t Result = ::rmdir(pathname); + SYSCALL_ERRNO(); +} + +auto link(FEXCore::Core::CpuStateFrame* Frame, const char* oldpath, const char* newpath) -> uint64_t { + uint64_t Result = ::link(oldpath, newpath); + SYSCALL_ERRNO(); +} + +auto unlink(FEXCore::Core::CpuStateFrame* Frame, const char* pathname) -> uint64_t { + uint64_t Result = ::unlink(pathname); + SYSCALL_ERRNO(); +} + +auto symlink(FEXCore::Core::CpuStateFrame* Frame, const char* target, const char* linkpath) -> uint64_t { + uint64_t Result = ::symlink(target, linkpath); + SYSCALL_ERRNO(); +} + +auto readlink(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(); +} + +auto chmod(FEXCore::Core::CpuStateFrame* Frame, const char* pathname, mode_t mode) -> uint64_t { + uint64_t Result = ::chmod(pathname, mode); + SYSCALL_ERRNO(); +} + +auto mknod(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(); +} + +auto creat(FEXCore::Core::CpuStateFrame* Frame, const char* pathname, mode_t mode) -> uint64_t { + uint64_t Result = ::creat(pathname, mode); + SYSCALL_ERRNO(); +} + +auto setxattr(FEXCore::Core::CpuStateFrame* Frame, const char* path, const char* name, const void* value, size_t size, int flags) -> uint64_t { + uint64_t Result = FEX::HLE::_SyscallHandler->FM.Setxattr(path, name, value, size, flags); + SYSCALL_ERRNO(); +} + +auto lsetxattr(FEXCore::Core::CpuStateFrame* Frame, const char* path, const char* name, const void* value, size_t size, int flags) -> uint64_t { + uint64_t Result = FEX::HLE::_SyscallHandler->FM.LSetxattr(path, name, value, size, flags); + SYSCALL_ERRNO(); +} + +auto getxattr(FEXCore::Core::CpuStateFrame* Frame, const char* path, const char* name, void* value, size_t size) -> uint64_t { + uint64_t Result = FEX::HLE::_SyscallHandler->FM.Getxattr(path, name, value, size); + SYSCALL_ERRNO(); +} + +auto lgetxattr(FEXCore::Core::CpuStateFrame* Frame, const char* path, const char* name, void* value, size_t size) -> uint64_t { + uint64_t Result = FEX::HLE::_SyscallHandler->FM.LGetxattr(path, name, value, size); + SYSCALL_ERRNO(); +} + +auto listxattr(FEXCore::Core::CpuStateFrame* Frame, const char* path, char* list, size_t size) -> uint64_t { + uint64_t Result = FEX::HLE::_SyscallHandler->FM.Listxattr(path, list, size); + SYSCALL_ERRNO(); +} + +auto llistxattr(FEXCore::Core::CpuStateFrame* Frame, const char* path, char* list, size_t size) -> uint64_t { + uint64_t Result = FEX::HLE::_SyscallHandler->FM.LListxattr(path, list, size); + SYSCALL_ERRNO(); +} + +auto removexattr(FEXCore::Core::CpuStateFrame* Frame, const char* path, const char* name) -> uint64_t { + uint64_t Result = FEX::HLE::_SyscallHandler->FM.Removexattr(path, name); + SYSCALL_ERRNO(); +} + +auto lremovexattr(FEXCore::Core::CpuStateFrame* Frame, const char* path, const char* name) -> uint64_t { + uint64_t Result = FEX::HLE::_SyscallHandler->FM.LRemovexattr(path, name); + SYSCALL_ERRNO(); +} +auto setxattrat(FEXCore::Core::CpuStateFrame* Frame, int dfd, const char* pathname, uint32_t at_flags, const char* name, + const FileManager::xattr_args* uargs, size_t usize) -> uint64_t { + if (!FEX::HLE::_SyscallHandler->IsHostKernelVersionAtLeast(6, 13, 0)) { + return -ENOSYS; + } + uint64_t Result = FEX::HLE::_SyscallHandler->FM.SetxattrAt(dfd, pathname, at_flags, name, uargs, usize); + SYSCALL_ERRNO(); +} +auto getxattrat(FEXCore::Core::CpuStateFrame* Frame, int dfd, const char* pathname, uint32_t at_flags, const char* name, + const FileManager::xattr_args* uargs, size_t usize) -> uint64_t { + + if (!FEX::HLE::_SyscallHandler->IsHostKernelVersionAtLeast(6, 13, 0)) { + return -ENOSYS; + } + uint64_t Result = FEX::HLE::_SyscallHandler->FM.GetxattrAt(dfd, pathname, at_flags, name, uargs, usize); + SYSCALL_ERRNO(); +} + +auto listxattrat(FEXCore::Core::CpuStateFrame* Frame, int dfd, const char* pathname, uint32_t at_flags, char* list, size_t size) -> uint64_t { + + if (!FEX::HLE::_SyscallHandler->IsHostKernelVersionAtLeast(6, 13, 0)) { + return -ENOSYS; + } + uint64_t Result = FEX::HLE::_SyscallHandler->FM.ListxattrAt(dfd, pathname, at_flags, list, size); + SYSCALL_ERRNO(); +} +auto removexattrat(FEXCore::Core::CpuStateFrame* Frame, int dfd, const char* pathname, uint32_t at_flags, const char* name) -> uint64_t { + + if (!FEX::HLE::_SyscallHandler->IsHostKernelVersionAtLeast(6, 13, 0)) { + return -ENOSYS; + } + uint64_t Result = FEX::HLE::_SyscallHandler->FM.RemovexattrAt(dfd, pathname, at_flags, name); + SYSCALL_ERRNO(); +} void RegisterFS(FEX::HLE::SyscallHandler* Handler) { using namespace FEXCore::IR; - REGISTER_SYSCALL_IMPL(rename, [](FEXCore::Core::CpuStateFrame* Frame, const char* oldpath, const char* newpath) -> uint64_t { - uint64_t Result = ::rename(oldpath, newpath); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(mkdir, [](FEXCore::Core::CpuStateFrame* Frame, const char* pathname, mode_t mode) -> uint64_t { - uint64_t Result = ::mkdir(pathname, mode); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(rmdir, [](FEXCore::Core::CpuStateFrame* Frame, const char* pathname) -> uint64_t { - uint64_t Result = ::rmdir(pathname); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(link, [](FEXCore::Core::CpuStateFrame* Frame, const char* oldpath, const char* newpath) -> uint64_t { - uint64_t Result = ::link(oldpath, newpath); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(unlink, [](FEXCore::Core::CpuStateFrame* Frame, const char* pathname) -> uint64_t { - uint64_t Result = ::unlink(pathname); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(symlink, [](FEXCore::Core::CpuStateFrame* Frame, const char* target, const char* linkpath) -> uint64_t { - uint64_t Result = ::symlink(target, linkpath); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(readlink, [](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(chmod, [](FEXCore::Core::CpuStateFrame* Frame, const char* pathname, mode_t mode) -> uint64_t { - uint64_t Result = ::chmod(pathname, mode); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(mknod, [](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(creat, [](FEXCore::Core::CpuStateFrame* Frame, const char* pathname, mode_t mode) -> uint64_t { - uint64_t Result = ::creat(pathname, mode); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL( - setxattr, [](FEXCore::Core::CpuStateFrame* Frame, const char* path, const char* name, const void* value, size_t size, int flags) -> uint64_t { - uint64_t Result = FEX::HLE::_SyscallHandler->FM.Setxattr(path, name, value, size, flags); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL( - lsetxattr, [](FEXCore::Core::CpuStateFrame* Frame, const char* path, const char* name, const void* value, size_t size, int flags) -> uint64_t { - uint64_t Result = FEX::HLE::_SyscallHandler->FM.LSetxattr(path, name, value, size, flags); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(getxattr, [](FEXCore::Core::CpuStateFrame* Frame, const char* path, const char* name, void* value, size_t size) -> uint64_t { - uint64_t Result = FEX::HLE::_SyscallHandler->FM.Getxattr(path, name, value, size); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(lgetxattr, [](FEXCore::Core::CpuStateFrame* Frame, const char* path, const char* name, void* value, size_t size) -> uint64_t { - uint64_t Result = FEX::HLE::_SyscallHandler->FM.LGetxattr(path, name, value, size); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(listxattr, [](FEXCore::Core::CpuStateFrame* Frame, const char* path, char* list, size_t size) -> uint64_t { - uint64_t Result = FEX::HLE::_SyscallHandler->FM.Listxattr(path, list, size); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(llistxattr, [](FEXCore::Core::CpuStateFrame* Frame, const char* path, char* list, size_t size) -> uint64_t { - uint64_t Result = FEX::HLE::_SyscallHandler->FM.LListxattr(path, list, size); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(removexattr, [](FEXCore::Core::CpuStateFrame* Frame, const char* path, const char* name) -> uint64_t { - uint64_t Result = FEX::HLE::_SyscallHandler->FM.Removexattr(path, name); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(lremovexattr, [](FEXCore::Core::CpuStateFrame* Frame, const char* path, const char* name) -> uint64_t { - uint64_t Result = FEX::HLE::_SyscallHandler->FM.LRemovexattr(path, name); - SYSCALL_ERRNO(); - }); - if (Handler->IsHostKernelVersionAtLeast(6, 13, 0)) { - REGISTER_SYSCALL_IMPL(setxattrat, - [](FEXCore::Core::CpuStateFrame* Frame, int dfd, const char* pathname, uint32_t at_flags, const char* name, - const FileManager::xattr_args* uargs, size_t usize) -> uint64_t { - uint64_t Result = FEX::HLE::_SyscallHandler->FM.SetxattrAt(dfd, pathname, at_flags, name, uargs, usize); - SYSCALL_ERRNO(); - }); - REGISTER_SYSCALL_IMPL(getxattrat, - [](FEXCore::Core::CpuStateFrame* Frame, int dfd, const char* pathname, uint32_t at_flags, const char* name, - const FileManager::xattr_args* uargs, size_t usize) -> uint64_t { - uint64_t Result = FEX::HLE::_SyscallHandler->FM.GetxattrAt(dfd, pathname, at_flags, name, uargs, usize); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL( - listxattrat, [](FEXCore::Core::CpuStateFrame* Frame, int dfd, const char* pathname, uint32_t at_flags, char* list, size_t size) -> uint64_t { - uint64_t Result = FEX::HLE::_SyscallHandler->FM.ListxattrAt(dfd, pathname, at_flags, list, size); - SYSCALL_ERRNO(); - }); - REGISTER_SYSCALL_IMPL( - removexattrat, [](FEXCore::Core::CpuStateFrame* Frame, int dfd, const char* pathname, uint32_t at_flags, const char* name) -> uint64_t { - uint64_t Result = FEX::HLE::_SyscallHandler->FM.RemovexattrAt(dfd, pathname, at_flags, name); - SYSCALL_ERRNO(); - }); - } else { - REGISTER_SYSCALL_IMPL(setxattrat, UnimplementedSyscallSafe); - REGISTER_SYSCALL_IMPL(getxattrat, UnimplementedSyscallSafe); - REGISTER_SYSCALL_IMPL(listxattrat, UnimplementedSyscallSafe); - REGISTER_SYSCALL_IMPL(removexattrat, UnimplementedSyscallSafe); - } + REGISTER_SYSCALL_IMPL(rename, rename); + REGISTER_SYSCALL_IMPL(mkdir, mkdir); + REGISTER_SYSCALL_IMPL(rmdir, rmdir); + REGISTER_SYSCALL_IMPL(link, link); + REGISTER_SYSCALL_IMPL(unlink, unlink); + REGISTER_SYSCALL_IMPL(symlink, symlink); + REGISTER_SYSCALL_IMPL(readlink, readlink); + REGISTER_SYSCALL_IMPL(chmod, chmod); + REGISTER_SYSCALL_IMPL(mknod, mknod); + REGISTER_SYSCALL_IMPL(creat, creat); + REGISTER_SYSCALL_IMPL(setxattr, setxattr); + REGISTER_SYSCALL_IMPL(lsetxattr, lsetxattr); + REGISTER_SYSCALL_IMPL(getxattr, getxattr); + REGISTER_SYSCALL_IMPL(lgetxattr, lgetxattr); + REGISTER_SYSCALL_IMPL(listxattr, listxattr); + REGISTER_SYSCALL_IMPL(llistxattr, llistxattr); + REGISTER_SYSCALL_IMPL(removexattr, removexattr); + REGISTER_SYSCALL_IMPL(lremovexattr, lremovexattr); + REGISTER_SYSCALL_IMPL(setxattrat, setxattrat); + REGISTER_SYSCALL_IMPL(getxattrat, getxattrat); + REGISTER_SYSCALL_IMPL(listxattrat, listxattrat); + REGISTER_SYSCALL_IMPL(removexattrat, removexattrat); } } // namespace FEX::HLE diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/IO.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/IO.cpp index a2e584ecdf..13d264be1f 100644 --- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/IO.cpp +++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/IO.cpp @@ -16,17 +16,16 @@ tags: LinuxSyscalls|syscalls-shared #include namespace FEX::HLE { +auto noperm(FEXCore::Core::CpuStateFrame* Frame, int level) -> uint64_t { + // Just claim we don't have permission + return -EPERM; +}; + + void RegisterIO(FEX::HLE::SyscallHandler* Handler) { using namespace FEXCore::IR; - REGISTER_SYSCALL_IMPL(iopl, [](FEXCore::Core::CpuStateFrame* Frame, int level) -> uint64_t { - // Just claim we don't have permission - return -EPERM; - }); - - REGISTER_SYSCALL_IMPL(ioperm, [](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(iopl, noperm); + REGISTER_SYSCALL_IMPL(ioperm, noperm); } } // namespace FEX::HLE diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Info.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Info.cpp index 3a9f2ef6a5..2b3e51dbdc 100644 --- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Info.cpp +++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Info.cpp @@ -34,86 +34,90 @@ namespace FEX::HLE { using cap_user_header_t = void*; using cap_user_data_t = void*; +auto uname(FEXCore::Core::CpuStateFrame* Frame, struct utsname* buf) -> uint64_t { + auto Thread = FEX::HLE::ThreadManager::GetStateObjectFromCPUState(Frame); + + struct utsname Local {}; + if (::uname(&Local) == 0) { + memcpy(buf->nodename, Local.nodename, sizeof(Local.nodename)); + static_assert(sizeof(Local.nodename) <= sizeof(buf->nodename)); + memcpy(buf->domainname, Local.domainname, sizeof(Local.domainname)); + static_assert(sizeof(Local.domainname) <= sizeof(buf->domainname)); + } else { + strcpy(buf->nodename, "FEXCore"); + LogMan::Msg::EFmt("Couldn't determine host nodename. Defaulting to '{}'", buf->nodename); + } + strcpy(buf->sysname, "Linux"); + uint32_t GuestVersion = FEX::HLE::_SyscallHandler->GetGuestKernelVersion(); + if (Thread->persona & UNAME26) { + // Kernel version converts from 6.x.y to 2.6.60+x. + GuestVersion = FEX::HLE::SyscallHandler::KernelVersion(2, 6, 60 + FEX::HLE::SyscallHandler::KernelMinor(GuestVersion)); + } + snprintf(buf->release, sizeof(buf->release), "%d.%d.%d", FEX::HLE::SyscallHandler::KernelMajor(GuestVersion), + FEX::HLE::SyscallHandler::KernelMinor(GuestVersion), FEX::HLE::SyscallHandler::KernelPatch(GuestVersion)); + + const char version[] = "#" GIT_DESCRIBE_STRING " SMP " __DATE__ " " __TIME__; + strcpy(buf->version, version); + static_assert(sizeof(version) <= sizeof(buf->version), "uname version define became too large!"); + if (Thread->persona & PER_LINUX32) { + // Tell the guest that we are a 32bit kernel + strcpy(buf->machine, "i686"); + } else { + // Tell the guest that we are a 64bit kernel + strcpy(buf->machine, "x86_64"); + } + return 0; +} + +auto personality(FEXCore::Core::CpuStateFrame* Frame, uint32_t persona) -> uint64_t { + auto Thread = FEX::HLE::ThreadManager::GetStateObjectFromCPUState(Frame); + + if (persona == ~0U) { + // Special case, only queries the persona. + return Thread->persona; + } + + // Mask off `PER_LINUX32` because AArch64 doesn't support it. + uint32_t NewPersona = persona & ~PER_LINUX32; + + // This syscall can not physically fail with PER_LINUX32 masked off. + // It also can not fail on a real x86 kernel. + (void)::syscall(SYSCALL_DEF(personality), NewPersona); + + // Return the old persona while setting the new one. + auto OldPersona = Thread->persona; + Thread->persona = persona; + return OldPersona; +} + +auto seccomp(FEXCore::Core::CpuStateFrame* Frame, unsigned int operation, unsigned int flags, void* args) -> uint64_t { + return FEX::HLE::_SyscallHandler->SeccompEmulator.Handle(Frame, operation, flags, args); +}; +auto ptrace(FEXCore::Core::CpuStateFrame* Frame, int /*enum __ptrace_request*/ request, pid_t pid, void* addr, void* data) -> uint64_t { + uint64_t Result {}; + + switch (request) { + case PTRACE_PEEKTEXT: + case PTRACE_PEEKDATA: + case PTRACE_POKETEXT: + case PTRACE_POKEDATA: + case PTRACE_ATTACH: + case PTRACE_DETACH: + // Passthrough these requests. Allows Wine to run the Ubisoft launcher. + Result = ::syscall(SYSCALL_DEF(ptrace), request, pid, addr, data); + SYSCALL_ERRNO(); + default: break; + } + // We don't support this + return -EPERM; +} + void RegisterInfo(FEX::HLE::SyscallHandler* Handler) { using namespace FEXCore::IR; - REGISTER_SYSCALL_IMPL(uname, [](FEXCore::Core::CpuStateFrame* Frame, struct utsname* buf) -> uint64_t { - auto Thread = FEX::HLE::ThreadManager::GetStateObjectFromCPUState(Frame); - - struct utsname Local {}; - if (::uname(&Local) == 0) { - memcpy(buf->nodename, Local.nodename, sizeof(Local.nodename)); - static_assert(sizeof(Local.nodename) <= sizeof(buf->nodename)); - memcpy(buf->domainname, Local.domainname, sizeof(Local.domainname)); - static_assert(sizeof(Local.domainname) <= sizeof(buf->domainname)); - } else { - strcpy(buf->nodename, "FEXCore"); - LogMan::Msg::EFmt("Couldn't determine host nodename. Defaulting to '{}'", buf->nodename); - } - strcpy(buf->sysname, "Linux"); - uint32_t GuestVersion = FEX::HLE::_SyscallHandler->GetGuestKernelVersion(); - if (Thread->persona & UNAME26) { - // Kernel version converts from 6.x.y to 2.6.60+x. - GuestVersion = FEX::HLE::SyscallHandler::KernelVersion(2, 6, 60 + FEX::HLE::SyscallHandler::KernelMinor(GuestVersion)); - } - snprintf(buf->release, sizeof(buf->release), "%d.%d.%d", FEX::HLE::SyscallHandler::KernelMajor(GuestVersion), - FEX::HLE::SyscallHandler::KernelMinor(GuestVersion), FEX::HLE::SyscallHandler::KernelPatch(GuestVersion)); - - const char version[] = "#" GIT_DESCRIBE_STRING " SMP " __DATE__ " " __TIME__; - strcpy(buf->version, version); - static_assert(sizeof(version) <= sizeof(buf->version), "uname version define became too large!"); - if (Thread->persona & PER_LINUX32) { - // Tell the guest that we are a 32bit kernel - strcpy(buf->machine, "i686"); - } else { - // Tell the guest that we are a 64bit kernel - strcpy(buf->machine, "x86_64"); - } - return 0; - }); - - REGISTER_SYSCALL_IMPL(personality, [](FEXCore::Core::CpuStateFrame* Frame, uint32_t persona) -> uint64_t { - auto Thread = FEX::HLE::ThreadManager::GetStateObjectFromCPUState(Frame); - - if (persona == ~0U) { - // Special case, only queries the persona. - return Thread->persona; - } - - // Mask off `PER_LINUX32` because AArch64 doesn't support it. - uint32_t NewPersona = persona & ~PER_LINUX32; - - // This syscall can not physically fail with PER_LINUX32 masked off. - // It also can not fail on a real x86 kernel. - (void)::syscall(SYSCALL_DEF(personality), NewPersona); - - // Return the old persona while setting the new one. - auto OldPersona = Thread->persona; - Thread->persona = persona; - return OldPersona; - }); - - REGISTER_SYSCALL_IMPL(seccomp, [](FEXCore::Core::CpuStateFrame* Frame, unsigned int operation, unsigned int flags, void* args) -> uint64_t { - return FEX::HLE::_SyscallHandler->SeccompEmulator.Handle(Frame, operation, flags, args); - }); - REGISTER_SYSCALL_IMPL( - ptrace, [](FEXCore::Core::CpuStateFrame* Frame, int /*enum __ptrace_request*/ request, pid_t pid, void* addr, void* data) -> uint64_t { - uint64_t Result {}; - - switch (request) { - case PTRACE_PEEKTEXT: - case PTRACE_PEEKDATA: - case PTRACE_POKETEXT: - case PTRACE_POKEDATA: - case PTRACE_ATTACH: - case PTRACE_DETACH: - // Passthrough these requests. Allows Wine to run the Ubisoft launcher. - Result = ::syscall(SYSCALL_DEF(ptrace), request, pid, addr, data); - SYSCALL_ERRNO(); - default: break; - } - // We don't support this - return -EPERM; - }); + REGISTER_SYSCALL_IMPL(uname, uname); + REGISTER_SYSCALL_IMPL(personality, personality); + REGISTER_SYSCALL_IMPL(seccomp, seccomp); + REGISTER_SYSCALL_IMPL(ptrace, ptrace); } } // namespace FEX::HLE diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Memory.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Memory.cpp index fd5ddbf76f..7bb2274250 100644 --- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Memory.cpp +++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Memory.cpp @@ -19,21 +19,23 @@ tags: LinuxSyscalls|syscalls-shared #include namespace FEX::HLE { -void RegisterMemory(FEX::HLE::SyscallHandler* Handler) { - using namespace FEXCore::IR; +auto brk(FEXCore::Core::CpuStateFrame* Frame, void* addr) -> uint64_t { + uint64_t Result = FEX::HLE::_SyscallHandler->HandleBRK(Frame, addr); + SYSCALL_ERRNO(); +} - REGISTER_SYSCALL_IMPL(brk, [](FEXCore::Core::CpuStateFrame* Frame, void* addr) -> uint64_t { - uint64_t Result = FEX::HLE::_SyscallHandler->HandleBRK(Frame, addr); - SYSCALL_ERRNO(); - }); +auto madvise(FEXCore::Core::CpuStateFrame* Frame, void* addr, size_t length, int32_t advice) -> uint64_t { + uint64_t Result = ::madvise(addr, length, advice); - REGISTER_SYSCALL_IMPL(madvise, [](FEXCore::Core::CpuStateFrame* Frame, void* addr, size_t length, int32_t advice) -> uint64_t { - uint64_t Result = ::madvise(addr, length, advice); + if (Result != -1) { + FEX::HLE::_SyscallHandler->TrackMadvise(Frame->Thread, (uintptr_t)addr, length, advice); + } + SYSCALL_ERRNO(); +} - if (Result != -1) { - FEX::HLE::_SyscallHandler->TrackMadvise(Frame->Thread, (uintptr_t)addr, length, advice); - } - SYSCALL_ERRNO(); - }); +void RegisterMemory(FEX::HLE::SyscallHandler* Handler) { + using namespace FEXCore::IR; + REGISTER_SYSCALL_IMPL(brk, brk); + REGISTER_SYSCALL_IMPL(madvise, madvise); } } // namespace FEX::HLE diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/NotImplemented.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/NotImplemented.cpp index b8a37b99cf..34f77a0969 100644 --- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/NotImplemented.cpp +++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/NotImplemented.cpp @@ -13,45 +13,75 @@ tags: LinuxSyscalls|syscalls-shared #include #include -#define REGISTER_SYSCALL_NOT_IMPL(name) \ - REGISTER_SYSCALL_IMPL(name, [](FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { \ - LogMan::Msg::DFmt("Using deprecated/removed syscall: " #name); \ - return -ENOSYS; \ - }); +#define SYSCALL_NOT_IMPL(name) \ + auto name(FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { \ + LogMan::Msg::DFmt("Using deprecated/removed syscall: " #name); \ + return -ENOSYS; \ + } -#define REGISTER_SYSCALL_NO_PERM(name) REGISTER_SYSCALL_IMPL(name, [](FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { return -EPERM; }); +#define SYSCALL_NO_PERM(name) \ + auto name(FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { \ + return -EPERM; \ + } -#define REGISTER_SYSCALL_NO_ACCESS(name) \ - REGISTER_SYSCALL_IMPL(name, [](FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { return -EACCES; }); +#define SYSCALL_NO_ACCESS(name) \ + auto name(FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { \ + return -EACCES; \ + } namespace FEX::HLE { // these are removed/not implemented in the linux kernel we present +SYSCALL_NOT_IMPL(ustat); +SYSCALL_NOT_IMPL(sysfs); +SYSCALL_NOT_IMPL(uselib); +SYSCALL_NOT_IMPL(create_module); +SYSCALL_NOT_IMPL(get_kernel_syms); +SYSCALL_NOT_IMPL(query_module); +SYSCALL_NOT_IMPL(nfsservctl); // Was removed in Linux 3.1 +SYSCALL_NOT_IMPL(getpmsg); +SYSCALL_NOT_IMPL(putpmsg); +SYSCALL_NOT_IMPL(afs_syscall); +SYSCALL_NOT_IMPL(vserver); +SYSCALL_NOT_IMPL(_sysctl); // Was removed in Linux 5.5 + +SYSCALL_NO_PERM(vhangup); +SYSCALL_NO_PERM(reboot) +SYSCALL_NO_PERM(sethostname); +SYSCALL_NO_PERM(setdomainname); +SYSCALL_NO_PERM(kexec_load); +SYSCALL_NO_PERM(finit_module); +SYSCALL_NO_PERM(bpf); +SYSCALL_NO_PERM(lookup_dcookie); +SYSCALL_NO_PERM(init_module) +SYSCALL_NO_PERM(delete_module); +SYSCALL_NO_PERM(quotactl); +SYSCALL_NO_ACCESS(perf_event_open); void RegisterNotImplemented(FEX::HLE::SyscallHandler* Handler) { - REGISTER_SYSCALL_NOT_IMPL(ustat); - REGISTER_SYSCALL_NOT_IMPL(sysfs); - REGISTER_SYSCALL_NOT_IMPL(uselib); - REGISTER_SYSCALL_NOT_IMPL(create_module); - REGISTER_SYSCALL_NOT_IMPL(get_kernel_syms); - REGISTER_SYSCALL_NOT_IMPL(query_module); - REGISTER_SYSCALL_NOT_IMPL(nfsservctl); // Was removed in Linux 3.1 - REGISTER_SYSCALL_NOT_IMPL(getpmsg); - REGISTER_SYSCALL_NOT_IMPL(putpmsg); - REGISTER_SYSCALL_NOT_IMPL(afs_syscall); - REGISTER_SYSCALL_NOT_IMPL(vserver); - REGISTER_SYSCALL_NOT_IMPL(_sysctl); // Was removed in Linux 5.5 - - REGISTER_SYSCALL_NO_PERM(vhangup); - REGISTER_SYSCALL_NO_PERM(reboot) - REGISTER_SYSCALL_NO_PERM(sethostname); - REGISTER_SYSCALL_NO_PERM(setdomainname); - REGISTER_SYSCALL_NO_PERM(kexec_load); - REGISTER_SYSCALL_NO_PERM(finit_module); - REGISTER_SYSCALL_NO_PERM(bpf); - REGISTER_SYSCALL_NO_PERM(lookup_dcookie); - REGISTER_SYSCALL_NO_PERM(init_module) - REGISTER_SYSCALL_NO_PERM(delete_module); - REGISTER_SYSCALL_NO_PERM(quotactl); - REGISTER_SYSCALL_NO_ACCESS(perf_event_open); + REGISTER_SYSCALL_IMPL(ustat, ustat); + REGISTER_SYSCALL_IMPL(sysfs, sysfs); + REGISTER_SYSCALL_IMPL(uselib, uselib); + REGISTER_SYSCALL_IMPL(create_module, create_module); + REGISTER_SYSCALL_IMPL(get_kernel_syms, get_kernel_syms); + REGISTER_SYSCALL_IMPL(query_module, query_module); + REGISTER_SYSCALL_IMPL(nfsservctl, nfsservctl); // Was removed in Linux 3.1 + REGISTER_SYSCALL_IMPL(getpmsg, getpmsg); + REGISTER_SYSCALL_IMPL(putpmsg, putpmsg); + REGISTER_SYSCALL_IMPL(afs_syscall, afs_syscall); + REGISTER_SYSCALL_IMPL(vserver, vserver); + REGISTER_SYSCALL_IMPL(_sysctl, _sysctl); // Was removed in Linux 5.5 + + REGISTER_SYSCALL_IMPL(vhangup, vhangup); + REGISTER_SYSCALL_IMPL(reboot, reboot); + REGISTER_SYSCALL_IMPL(sethostname, sethostname); + REGISTER_SYSCALL_IMPL(setdomainname, setdomainname); + REGISTER_SYSCALL_IMPL(kexec_load, kexec_load); + REGISTER_SYSCALL_IMPL(finit_module, finit_module); + REGISTER_SYSCALL_IMPL(bpf, bpf); + REGISTER_SYSCALL_IMPL(lookup_dcookie, lookup_dcookie); + REGISTER_SYSCALL_IMPL(init_module, init_module); + REGISTER_SYSCALL_IMPL(delete_module, delete_module); + REGISTER_SYSCALL_IMPL(quotactl, quotactl); + REGISTER_SYSCALL_IMPL(perf_event_open, perf_event_open); } } // namespace FEX::HLE diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Signals.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Signals.cpp index b59d9bf066..ee62cbf8b5 100644 --- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Signals.cpp +++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Signals.cpp @@ -14,7 +14,6 @@ tags: LinuxSyscalls|syscalls-shared #include #include -#include #include #include @@ -23,36 +22,42 @@ struct GuestSigAction; } namespace FEX::HLE { +auto rt_sigprocmask(FEXCore::Core::CpuStateFrame* Frame, int how, const uint64_t* set, uint64_t* oldset) -> uint64_t { + return FEX::HLE::_SyscallHandler->GetSignalDelegator()->GuestSigProcMask(FEX::HLE::ThreadManager::GetStateObjectFromCPUState(Frame), how, + set, oldset); +} + +auto rt_sigpending(FEXCore::Core::CpuStateFrame* Frame, uint64_t* set, size_t sigsetsize) -> uint64_t { + return FEX::HLE::_SyscallHandler->GetSignalDelegator()->GuestSigPending(FEX::HLE::ThreadManager::GetStateObjectFromCPUState(Frame), set, + sigsetsize); +} + +auto rt_sigsuspend(FEXCore::Core::CpuStateFrame* Frame, uint64_t* unewset, size_t sigsetsize) -> uint64_t { + return FEX::HLE::_SyscallHandler->GetSignalDelegator()->GuestSigSuspend(FEX::HLE::ThreadManager::GetStateObjectFromCPUState(Frame), + unewset, sigsetsize); +} + +auto userfaultfd(FEXCore::Core::CpuStateFrame* Frame, int flags) -> uint64_t { + // Disable userfaultfd until we can properly emulate it + // This is okay because the kernel configuration allows you to disable it at compile time + return -ENOSYS; + uint64_t Result = ::syscall(SYSCALL_DEF(userfaultfd), flags); + SYSCALL_ERRNO(); +} + +auto signalfd(FEXCore::Core::CpuStateFrame* Frame, int fd, const uint64_t* mask, size_t sigsetsize) -> uint64_t { + return FEX::HLE::_SyscallHandler->GetSignalDelegator()->GuestSignalFD(fd, mask, sigsetsize, 0); +} + +auto signalfd4(FEXCore::Core::CpuStateFrame* Frame, int fd, const uint64_t* mask, size_t sigsetsize, int flags) -> uint64_t { + return FEX::HLE::_SyscallHandler->GetSignalDelegator()->GuestSignalFD(fd, mask, sigsetsize, flags); +} void RegisterSignals(FEX::HLE::SyscallHandler* Handler) { - REGISTER_SYSCALL_IMPL(rt_sigprocmask, [](FEXCore::Core::CpuStateFrame* Frame, int how, const uint64_t* set, uint64_t* oldset) -> uint64_t { - return FEX::HLE::_SyscallHandler->GetSignalDelegator()->GuestSigProcMask(FEX::HLE::ThreadManager::GetStateObjectFromCPUState(Frame), - how, set, oldset); - }); - - REGISTER_SYSCALL_IMPL(rt_sigpending, [](FEXCore::Core::CpuStateFrame* Frame, uint64_t* set, size_t sigsetsize) -> uint64_t { - return FEX::HLE::_SyscallHandler->GetSignalDelegator()->GuestSigPending(FEX::HLE::ThreadManager::GetStateObjectFromCPUState(Frame), set, - sigsetsize); - }); - - REGISTER_SYSCALL_IMPL(rt_sigsuspend, [](FEXCore::Core::CpuStateFrame* Frame, uint64_t* unewset, size_t sigsetsize) -> uint64_t { - return FEX::HLE::_SyscallHandler->GetSignalDelegator()->GuestSigSuspend(FEX::HLE::ThreadManager::GetStateObjectFromCPUState(Frame), - unewset, sigsetsize); - }); - - REGISTER_SYSCALL_IMPL(userfaultfd, [](FEXCore::Core::CpuStateFrame* Frame, int flags) -> uint64_t { - // Disable userfaultfd until we can properly emulate it - // This is okay because the kernel configuration allows you to disable it at compile time - return -ENOSYS; - uint64_t Result = ::syscall(SYSCALL_DEF(userfaultfd), flags); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(signalfd, [](FEXCore::Core::CpuStateFrame* Frame, int fd, const uint64_t* mask, size_t sigsetsize) -> uint64_t { - return FEX::HLE::_SyscallHandler->GetSignalDelegator()->GuestSignalFD(fd, mask, sigsetsize, 0); - }); - - REGISTER_SYSCALL_IMPL(signalfd4, [](FEXCore::Core::CpuStateFrame* Frame, int fd, const uint64_t* mask, size_t sigsetsize, int flags) -> uint64_t { - return FEX::HLE::_SyscallHandler->GetSignalDelegator()->GuestSignalFD(fd, mask, sigsetsize, flags); - }); + REGISTER_SYSCALL_IMPL(rt_sigprocmask, rt_sigprocmask); + REGISTER_SYSCALL_IMPL(rt_sigpending, rt_sigpending); + REGISTER_SYSCALL_IMPL(rt_sigsuspend, rt_sigsuspend); + REGISTER_SYSCALL_IMPL(userfaultfd, userfaultfd); + REGISTER_SYSCALL_IMPL(signalfd, signalfd); + REGISTER_SYSCALL_IMPL(signalfd4, signalfd4); } } // namespace FEX::HLE diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Stubs.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Stubs.cpp index 2c3edeef10..02e72424ec 100644 --- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Stubs.cpp +++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Stubs.cpp @@ -15,23 +15,21 @@ tags: LinuxSyscalls|syscalls-shared #include #include -#define SYSCALL_STUB(name) \ - do { \ - ERROR_AND_DIE_FMT("Syscall: " #name " stub!"); \ - return -ENOSYS; \ - } while (0) - namespace FEXCore::Core { struct CpuStateFrame; } namespace FEX::HLE { -void RegisterStubs(FEX::HLE::SyscallHandler* Handler) { - REGISTER_SYSCALL_IMPL(restart_syscall, [](FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { SYSCALL_STUB(restart_syscall); }); +auto stub_fault(FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { + ERROR_AND_DIE_FMT("Syscall: stub!"); + return -ENOSYS; +} +auto stub(FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { + return -ENOSYS; +} - REGISTER_SYSCALL_IMPL(rseq, [](FEXCore::Core::CpuStateFrame* Frame, struct rseq* rseq, uint32_t rseq_len, int flags, uint32_t sig) -> uint64_t { - // We don't support this - return -ENOSYS; - }); +void RegisterStubs(FEX::HLE::SyscallHandler* Handler) { + REGISTER_SYSCALL_IMPL(restart_syscall, stub_fault); + REGISTER_SYSCALL_IMPL(rseq, stub); } } // namespace FEX::HLE diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Thread.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Thread.cpp index 47e1d0c976..4e889aaedf 100644 --- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Thread.cpp +++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Thread.cpp @@ -390,191 +390,206 @@ uint64_t ForkGuest(FEXCore::Core::InternalThreadState* Thread, FEXCore::Core::Cp } } -void RegisterThread(FEX::HLE::SyscallHandler* Handler) { - using namespace FEXCore::IR; - - REGISTER_SYSCALL_IMPL(rt_sigreturn, [](FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { - FEX::HLE::_SyscallHandler->GetSignalDelegator()->HandleSignalHandlerReturn(true); - FEX_UNREACHABLE; - }); - - REGISTER_SYSCALL_IMPL(fork, ([](FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { - FEX::HLE::clone3_args args {.Type = TypeOfClone::TYPE_CLONE2, - .args = { - .flags = 0, - .pidfd = 0, - .child_tid = 0, - .parent_tid = 0, - .exit_signal = SIGCHLD, - .stack = 0, - .stack_size = 0, - .tls = 0, - .set_tid = 0, - .set_tid_size = 0, - .cgroup = 0, - }}; - - return ForkGuest(Frame->Thread, Frame, &args); - })); - - REGISTER_SYSCALL_IMPL(vfork, ([](FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { - FEX::HLE::clone3_args args {.Type = TypeOfClone::TYPE_CLONE2, - .args = { - .flags = CLONE_VFORK, - .pidfd = 0, - .child_tid = 0, - .parent_tid = 0, - .exit_signal = SIGCHLD, - .stack = 0, - .stack_size = 0, - .tls = 0, - .set_tid = 0, - .set_tid_size = 0, - .cgroup = 0, - }}; - - return ForkGuest(Frame->Thread, Frame, &args); - })); - - REGISTER_SYSCALL_IMPL(getpgrp, [](FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { - uint64_t Result = ::getpgrp(); - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(clone3, ([](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(exit, [](FEXCore::Core::CpuStateFrame* Frame, int status) -> uint64_t { - // TLS/DTV teardown is something FEX can't control. Disable glibc checking when we leave a pthread. - // Since this thread is hard stopping, we can't track the TLS/DTV teardown in FEX's thread handling. - FEXCore::Allocator::YesIKnowImNotSupposedToUseTheGlibcAllocator::HardDisable(); - auto ThreadObject = FEX::HLE::ThreadManager::GetStateObjectFromCPUState(Frame); - - if (ThreadObject->ThreadInfo.clear_child_tid) { - auto Addr = std::atomic_ref(*ThreadObject->ThreadInfo.clear_child_tid); - Addr.store(0); - syscall(SYSCALL_DEF(futex), ThreadObject->ThreadInfo.clear_child_tid, FUTEX_WAKE, ~0ULL, 0, 0, 0); - } +using namespace FEXCore::IR; - ThreadObject->StatusCode = status; +auto rt_sigreturn(FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { + FEX::HLE::_SyscallHandler->GetSignalDelegator()->HandleSignalHandlerReturn(true); + FEX_UNREACHABLE; +} - FEX::HLE::_SyscallHandler->UninstallTLSState(ThreadObject); +auto fork(FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { + FEX::HLE::clone3_args args {.Type = TypeOfClone::TYPE_CLONE2, + .args = { + .flags = 0, + .pidfd = 0, + .child_tid = 0, + .parent_tid = 0, + .exit_signal = SIGCHLD, + .stack = 0, + .stack_size = 0, + .tls = 0, + .set_tid = 0, + .set_tid_size = 0, + .cgroup = 0, + }}; + + return ForkGuest(Frame->Thread, Frame, &args); +} - if (ThreadObject->ExecutionThread) { - // If this is a pthread based execution thread, then there is more work to be done. - // Delegate final deletion and cleanup to the pthreads Thread management. - FEX::LinuxEmulation::Threads::LongjumpDeallocateAndExit(ThreadObject, status); - } else { - FEX::HLE::_SyscallHandler->TM.DestroyThread(ThreadObject, true); - FEX::LinuxEmulation::Threads::DeallocateStackObjectAndExit(nullptr, status); - } - // This will never be reached - std::terminate(); - }); - - REGISTER_SYSCALL_IMPL(prctl, - [](FEXCore::Core::CpuStateFrame* Frame, int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, - unsigned long arg5) -> uint64_t { - uint64_t Result {}; +auto vfork(FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { + FEX::HLE::clone3_args args {.Type = TypeOfClone::TYPE_CLONE2, + .args = { + .flags = CLONE_VFORK, + .pidfd = 0, + .child_tid = 0, + .parent_tid = 0, + .exit_signal = SIGCHLD, + .stack = 0, + .stack_size = 0, + .tls = 0, + .set_tid = 0, + .set_tid_size = 0, + .cgroup = 0, + }}; + + return ForkGuest(Frame->Thread, Frame, &args); +} + +auto getpgrp(FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { + uint64_t Result = ::getpgrp(); + SYSCALL_ERRNO(); +} + +auto clone3(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); +} + +auto exit(FEXCore::Core::CpuStateFrame* Frame, int status) -> uint64_t { + // TLS/DTV teardown is something FEX can't control. Disable glibc checking when we leave a pthread. + // Since this thread is hard stopping, we can't track the TLS/DTV teardown in FEX's thread handling. + FEXCore::Allocator::YesIKnowImNotSupposedToUseTheGlibcAllocator::HardDisable(); + auto ThreadObject = FEX::HLE::ThreadManager::GetStateObjectFromCPUState(Frame); + + if (ThreadObject->ThreadInfo.clear_child_tid) { + auto Addr = std::atomic_ref(*ThreadObject->ThreadInfo.clear_child_tid); + Addr.store(0); + syscall(SYSCALL_DEF(futex), ThreadObject->ThreadInfo.clear_child_tid, FUTEX_WAKE, ~0ULL, 0, 0, 0); + } + + ThreadObject->StatusCode = status; + + FEX::HLE::_SyscallHandler->UninstallTLSState(ThreadObject); + + if (ThreadObject->ExecutionThread) { + // If this is a pthread based execution thread, then there is more work to be done. + // Delegate final deletion and cleanup to the pthreads Thread management. + FEX::LinuxEmulation::Threads::LongjumpDeallocateAndExit(ThreadObject, status); + } else { + FEX::HLE::_SyscallHandler->TM.DestroyThread(ThreadObject, true); + FEX::LinuxEmulation::Threads::DeallocateStackObjectAndExit(nullptr, status); + } + // This will never be reached + std::terminate(); +} + +auto prctl(FEXCore::Core::CpuStateFrame* Frame, int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5) + -> uint64_t { + uint64_t Result {}; #ifndef PR_GET_AUXV #define PR_GET_AUXV 0x41555856 #endif - switch (option) { - case PR_SET_SECCOMP: { - uint32_t Operation {}; - if (arg2 == SECCOMP_MODE_STRICT) Operation = SECCOMP_SET_MODE_STRICT; - if (arg2 == SECCOMP_MODE_FILTER) Operation = SECCOMP_SET_MODE_FILTER; - - return FEX::HLE::_SyscallHandler->SeccompEmulator.Handle(Frame, Operation, 0, reinterpret_cast(arg3)); - } - case PR_GET_SECCOMP: return FEX::HLE::_SyscallHandler->SeccompEmulator.GetSeccomp(Frame); - case PR_GET_AUXV: { - if (arg4 || arg5) { - return -EINVAL; - } - - void* addr = reinterpret_cast(arg2); - size_t UserSize = reinterpret_cast(arg3); - - const auto auxv = FEX::HLE::_SyscallHandler->GetCodeLoader()->GetAuxv(); - const auto auxvBase = auxv.address; - const auto auxvSize = auxv.size; - size_t MinSize = std::min(auxvSize, UserSize); - - memcpy(addr, reinterpret_cast(auxvBase), MinSize); - - // Returns the size of auxv without truncation. - return auxvSize; - } - default: Result = ::prctl(option, arg2, arg3, arg4, arg5); break; - } - SYSCALL_ERRNO(); - }); - - REGISTER_SYSCALL_IMPL(arch_prctl, [](FEXCore::Core::CpuStateFrame* Frame, int code, unsigned long addr) -> uint64_t { - uint64_t Result {}; - switch (code) { - case 0x1001: // ARCH_SET_GS - if (addr >= SyscallHandler::TASK_MAX_64BIT) { - // Ignore a non-canonical address - return -EPERM; - } - Frame->State.gs_cached = addr; - Result = 0; - break; - case 0x1002: // ARCH_SET_FS - if (addr >= SyscallHandler::TASK_MAX_64BIT) { - // Ignore a non-canonical address - return -EPERM; - } - Frame->State.fs_cached = addr; - Result = 0; - break; - case 0x1003: // ARCH_GET_FS - *reinterpret_cast(addr) = Frame->State.fs_cached; - Result = 0; - break; - case 0x1004: // ARCH_GET_GS - *reinterpret_cast(addr) = Frame->State.gs_cached; - Result = 0; - break; - case 0x3001: // ARCH_CET_STATUS - Result = -EINVAL; // We don't support CET, return EINVAL - break; - case 0x1011: // ARCH_GET_CPUID - return 1; - break; - case 0x1012: // ARCH_SET_CPUID - return -ENODEV; // Claim we don't support faulting on CPUID - break; - default: - LogMan::Msg::EFmt("Unknown prctl: 0x{:x}", code); - Result = -EINVAL; - break; + switch (option) { + case PR_SET_SECCOMP: { + uint32_t Operation {}; + if (arg2 == SECCOMP_MODE_STRICT) { + Operation = SECCOMP_SET_MODE_STRICT; + } + if (arg2 == SECCOMP_MODE_FILTER) { + Operation = SECCOMP_SET_MODE_FILTER; + } + + return FEX::HLE::_SyscallHandler->SeccompEmulator.Handle(Frame, Operation, 0, reinterpret_cast(arg3)); + } + case PR_GET_SECCOMP: return FEX::HLE::_SyscallHandler->SeccompEmulator.GetSeccomp(Frame); + case PR_GET_AUXV: { + if (arg4 || arg5) { + return -EINVAL; } - SYSCALL_ERRNO(); - }); - REGISTER_SYSCALL_IMPL(set_tid_address, [](FEXCore::Core::CpuStateFrame* Frame, int* tidptr) -> uint64_t { - auto ThreadObject = FEX::HLE::ThreadManager::GetStateObjectFromCPUState(Frame); - ThreadObject->ThreadInfo.clear_child_tid = tidptr; - return ThreadObject->ThreadInfo.TID; - }); + void* addr = reinterpret_cast(arg2); + size_t UserSize = reinterpret_cast(arg3); - REGISTER_SYSCALL_IMPL(exit_group, [](FEXCore::Core::CpuStateFrame* Frame, int status) -> uint64_t { - Frame->Thread->CTX->FlushAndCloseCodeMap(); + const auto auxv = FEX::HLE::_SyscallHandler->GetCodeLoader()->GetAuxv(); + const auto auxvBase = auxv.address; + const auto auxvSize = auxv.size; + size_t MinSize = std::min(auxvSize, UserSize); - // Save telemetry if we're exiting. - FEX::HLE::_SyscallHandler->GetSignalDelegator()->SaveTelemetry(); - FEX::HLE::_SyscallHandler->TM.CleanupForExit(); + memcpy(addr, reinterpret_cast(auxvBase), MinSize); - syscall(SYSCALL_DEF(exit_group), status); - // This will never be reached - std::terminate(); - }); + // Returns the size of auxv without truncation. + return auxvSize; + } + default: Result = ::prctl(option, arg2, arg3, arg4, arg5); break; + } + SYSCALL_ERRNO(); +} + +auto arch_prctl(FEXCore::Core::CpuStateFrame* Frame, int code, unsigned long addr) -> uint64_t { + uint64_t Result {}; + switch (code) { + case 0x1001: // ARCH_SET_GS + if (addr >= SyscallHandler::TASK_MAX_64BIT) { + // Ignore a non-canonical address + return -EPERM; + } + Frame->State.gs_cached = addr; + Result = 0; + break; + case 0x1002: // ARCH_SET_FS + if (addr >= SyscallHandler::TASK_MAX_64BIT) { + // Ignore a non-canonical address + return -EPERM; + } + Frame->State.fs_cached = addr; + Result = 0; + break; + case 0x1003: // ARCH_GET_FS + *reinterpret_cast(addr) = Frame->State.fs_cached; + Result = 0; + break; + case 0x1004: // ARCH_GET_GS + *reinterpret_cast(addr) = Frame->State.gs_cached; + Result = 0; + break; + case 0x3001: // ARCH_CET_STATUS + Result = -EINVAL; // We don't support CET, return EINVAL + break; + case 0x1011: // ARCH_GET_CPUID + return 1; + break; + case 0x1012: // ARCH_SET_CPUID + return -ENODEV; // Claim we don't support faulting on CPUID + break; + default: + LogMan::Msg::EFmt("Unknown prctl: 0x{:x}", code); + Result = -EINVAL; + break; + } + SYSCALL_ERRNO(); +} + +auto set_tid_address(FEXCore::Core::CpuStateFrame* Frame, int* tidptr) -> uint64_t { + auto ThreadObject = FEX::HLE::ThreadManager::GetStateObjectFromCPUState(Frame); + ThreadObject->ThreadInfo.clear_child_tid = tidptr; + return ThreadObject->ThreadInfo.TID; +} + +auto exit_group(FEXCore::Core::CpuStateFrame* Frame, int status) -> uint64_t { + Frame->Thread->CTX->FlushAndCloseCodeMap(); + + // Save telemetry if we're exiting. + FEX::HLE::_SyscallHandler->GetSignalDelegator()->SaveTelemetry(); + FEX::HLE::_SyscallHandler->TM.CleanupForExit(); + + syscall(SYSCALL_DEF(exit_group), status); + // This will never be reached + std::terminate(); +} + + +void RegisterThread(FEX::HLE::SyscallHandler* Handler) { + REGISTER_SYSCALL_IMPL(rt_sigreturn, rt_sigreturn); + REGISTER_SYSCALL_IMPL(fork, fork); + REGISTER_SYSCALL_IMPL(vfork, vfork); + REGISTER_SYSCALL_IMPL(getpgrp, getpgrp); + REGISTER_SYSCALL_IMPL(clone3, clone3); + REGISTER_SYSCALL_IMPL(exit, exit); + REGISTER_SYSCALL_IMPL(prctl, prctl); + REGISTER_SYSCALL_IMPL(arch_prctl, arch_prctl); + REGISTER_SYSCALL_IMPL(set_tid_address, set_tid_address); + REGISTER_SYSCALL_IMPL(exit_group, exit_group); } } // namespace FEX::HLE diff --git a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Timer.cpp b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Timer.cpp index 059038dafd..d244dc015e 100644 --- a/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Timer.cpp +++ b/Source/Tools/LinuxEmulation/LinuxSyscalls/Syscalls/Timer.cpp @@ -6,7 +6,6 @@ tags: LinuxSyscalls|syscalls-shared */ #include "LinuxSyscalls/Syscalls.h" -#include "LinuxSyscalls/Types.h" #include "LinuxSyscalls/x64/Syscalls.h" #include "LinuxSyscalls/x32/Syscalls.h" @@ -14,24 +13,24 @@ tags: LinuxSyscalls|syscalls-shared #include #include -#include #include -#include #include #include namespace FEX::HLE { -void RegisterTimer(FEX::HLE::SyscallHandler* Handler) { - using namespace FEXCore::IR; +auto alarm(FEXCore::Core::CpuStateFrame* Frame, unsigned int seconds) -> uint64_t { + uint64_t Result = ::alarm(seconds); + SYSCALL_ERRNO(); +} - REGISTER_SYSCALL_IMPL(alarm, [](FEXCore::Core::CpuStateFrame* Frame, unsigned int seconds) -> uint64_t { - uint64_t Result = ::alarm(seconds); - SYSCALL_ERRNO(); - }); +auto pause(FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { + uint64_t Result = ::pause(); + SYSCALL_ERRNO(); +} - REGISTER_SYSCALL_IMPL(pause, [](FEXCore::Core::CpuStateFrame* Frame) -> uint64_t { - uint64_t Result = ::pause(); - SYSCALL_ERRNO(); - }); +void RegisterTimer(FEX::HLE::SyscallHandler* Handler) { + using namespace FEXCore::IR; + REGISTER_SYSCALL_IMPL(alarm, alarm); + REGISTER_SYSCALL_IMPL(pause, pause); } } // namespace FEX::HLE