Merge pull request #392 from Sonicadvance1/more_syscalls2

Spam out a wackload more syscalls

External/FEXCore/Source/CMakeLists.txt

@@ -153,7 +153,9 @@ set (SRCS
   Interface/HLE/Syscalls/Info.cpp
   Interface/HLE/Syscalls/IO.cpp
   Interface/HLE/Syscalls/Ioctl.cpp
+  Interface/HLE/Syscalls/Key.cpp
   Interface/HLE/Syscalls/Memory.cpp
+  Interface/HLE/Syscalls/Msg.cpp
   Interface/HLE/Syscalls/Sched.cpp
   Interface/HLE/Syscalls/Semaphore.cpp
   Interface/HLE/Syscalls/SHM.cpp

External/FEXCore/Source/Interface/HLE/Syscalls/FD.cpp

@@ -17,6 +17,8 @@
 #include <sys/stat.h>
 #include <unistd.h>
 #include <sys/eventfd.h>
+#include <sys/sendfile.h>
+#include <sys/time.h>
 
 namespace FEXCore::HLE {
   static void CopyStat(FEXCore::guest_stat *guest, struct stat *host) {
@@ -185,6 +187,11 @@ namespace FEXCore::HLE {
       SYSCALL_ERRNO();
     });
 
+    REGISTER_SYSCALL_IMPL(sendfile, [](FEXCore::Core::InternalThreadState *Thread, int out_fd, int in_fd, off_t *offset, size_t count) -> uint64_t {
+      uint64_t Result = ::sendfile(out_fd, in_fd, offset, count);
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL(dup3, [](FEXCore::Core::InternalThreadState* Thread, int oldfd, int newfd, int flags) -> uint64_t {
       flags = RemapFlags(flags);
       uint64_t Result = ::dup3(oldfd, newfd, flags);
@@ -239,6 +246,11 @@ namespace FEXCore::HLE {
       SYSCALL_ERRNO();
     });
 
+    REGISTER_SYSCALL_IMPL(readahead, [](FEXCore::Core::InternalThreadState *Thread, int fd, off64_t offset, size_t count) -> uint64_t {
+      uint64_t Result = ::readahead(fd, offset, count);
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL(getdents64, [](FEXCore::Core::InternalThreadState *Thread, int fd, void *dirp, uint32_t count) -> uint64_t {
       uint64_t Result = syscall(SYS_getdents64,
         static_cast<uint64_t>(fd),
@@ -273,6 +285,26 @@ namespace FEXCore::HLE {
       SYSCALL_ERRNO();
     });
 
+    REGISTER_SYSCALL_IMPL(mkdirat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, mode_t mode) -> uint64_t {
+      uint64_t Result = ::mkdirat(dirfd, pathname, mode);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(mknodat, [](FEXCore::Core::InternalThreadState *Thread, 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(fchownat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, uid_t owner, gid_t group, int flags) -> uint64_t {
+      uint64_t Result = ::fchownat(dirfd, pathname, owner, group, flags);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(futimesat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, const struct timeval times[2]) -> uint64_t {
+      uint64_t Result = ::futimesat(dirfd, pathname, times);
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL(newfstatat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, FEXCore::guest_stat *buf, int flag) -> uint64_t {
       struct stat host_stat;
       uint64_t Result = ::fstatat(dirfd, pathname, &host_stat, flag);
@@ -282,16 +314,66 @@ namespace FEXCore::HLE {
       SYSCALL_ERRNO();
     });
 
+    REGISTER_SYSCALL_IMPL(unlinkat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, int flags) -> uint64_t {
+      uint64_t Result = ::unlinkat(dirfd, pathname, flags);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(renameat, [](FEXCore::Core::InternalThreadState *Thread, 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(linkat, [](FEXCore::Core::InternalThreadState *Thread, int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags) -> uint64_t {
+      uint64_t Result = ::linkat(olddirfd, oldpath, newdirfd, newpath, flags);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(symlinkat, [](FEXCore::Core::InternalThreadState *Thread, const char *target, int newdirfd, const char *linkpath) -> uint64_t {
+      uint64_t Result = ::symlinkat(target, newdirfd, linkpath);
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL(readlinkat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, char *buf, size_t bufsiz) -> uint64_t {
       uint64_t Result = Thread->CTX->SyscallHandler->FM.Readlinkat(dirfd, pathname, buf, bufsiz);
       SYSCALL_ERRNO();
     });
 
+    REGISTER_SYSCALL_IMPL(fchmodat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, mode_t mode, int flags) -> uint64_t {
+      uint64_t Result = fchmodat(dirfd, pathname, mode, flags);
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL(faccessat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, int mode, int flags) -> uint64_t {
       uint64_t Result = Thread->CTX->SyscallHandler->FM.FAccessat(dirfd, pathname, mode, flags);
       SYSCALL_ERRNO();
     });
 
+    REGISTER_SYSCALL_IMPL(splice, [](FEXCore::Core::InternalThreadState *Thread, int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags) -> uint64_t {
+      uint64_t Result = ::splice(fd_in, off_in, fd_out, off_out, len, flags);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(tee, [](FEXCore::Core::InternalThreadState *Thread, int fd_in, int fd_out, size_t len, unsigned int flags) -> uint64_t {
+      uint64_t Result = ::tee(fd_in, fd_out, len, flags);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(sync_file_range, [](FEXCore::Core::InternalThreadState *Thread, int fd, off64_t offset, off64_t nbytes, unsigned int flags) -> uint64_t {
+      uint64_t Result = ::sync_file_range(fd, offset, nbytes, flags);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(vmsplice, [](FEXCore::Core::InternalThreadState *Thread, int fd, const struct iovec *iov, unsigned long nr_segs, unsigned int flags) -> uint64_t {
+      uint64_t Result = ::vmsplice(fd, iov, nr_segs, flags);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(utimensat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, const struct timespec times[2], int flags) -> uint64_t {
+      uint64_t Result = ::utimensat(dirfd, pathname, times, flags);
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL(timerfd_create, [](FEXCore::Core::InternalThreadState *Thread, int32_t clockid, int32_t flags) -> uint64_t {
       uint64_t Result = ::timerfd_create(clockid, flags);
       SYSCALL_ERRNO();
@@ -324,6 +406,11 @@ namespace FEXCore::HLE {
       SYSCALL_ERRNO();
     });
 
+    REGISTER_SYSCALL_IMPL(renameat2, [](FEXCore::Core::InternalThreadState *Thread, int olddirfd, const char *oldpath, int newdirfd, const char *newpath, unsigned int flags) -> uint64_t {
+      uint64_t Result = ::renameat2(olddirfd, oldpath, newdirfd, newpath, flags);
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL(memfd_create, [](FEXCore::Core::InternalThreadState *Thread, const char *name, uint32_t flags) -> uint64_t {
       uint64_t Result = ::memfd_create(name, flags);
       SYSCALL_ERRNO();
@@ -358,8 +445,42 @@ namespace FEXCore::HLE {
     });
 
     REGISTER_SYSCALL_IMPL(eventfd2, [](FEXCore::Core::InternalThreadState *Thread, unsigned int initval, int flags) -> uint64_t {
-      uint64_t Result = eventfd(initval, flags);
+      uint64_t Result = ::eventfd(initval, flags);
+      SYSCALL_ERRNO();
+    });
 
+    REGISTER_SYSCALL_IMPL(preadv, [](FEXCore::Core::InternalThreadState *Thread, int fd, const struct iovec *iov, int iovcnt, off_t offset) -> uint64_t {
+      uint64_t Result = ::preadv(fd, iov, iovcnt, offset);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(pwritev, [](FEXCore::Core::InternalThreadState *Thread, int fd, const struct iovec *iov, int iovcnt, off_t offset) -> uint64_t {
+      uint64_t Result = ::pwritev(fd, iov, iovcnt, offset);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(preadv2, [](FEXCore::Core::InternalThreadState *Thread, int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) -> uint64_t {
+      uint64_t Result = ::preadv2(fd, iov, iovcnt, offset, flags);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(pwritev2, [](FEXCore::Core::InternalThreadState *Thread, int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) -> uint64_t {
+      uint64_t Result = ::pwritev2(fd, iov, iovcnt, offset, flags);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(process_vm_readv, [](FEXCore::Core::InternalThreadState *Thread, pid_t pid, const struct iovec *local_iov, unsigned long liovcnt, const struct iovec *remote_iov, unsigned long riovcnt, unsigned long flags) -> uint64_t {
+      uint64_t Result = ::process_vm_readv(pid, local_iov, liovcnt, remote_iov, riovcnt, flags);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(process_vm_writev, [](FEXCore::Core::InternalThreadState *Thread, pid_t pid, const struct iovec *local_iov, unsigned long liovcnt, const struct iovec *remote_iov, unsigned long riovcnt, unsigned long flags) -> uint64_t {
+      uint64_t Result = ::process_vm_writev(pid, local_iov, liovcnt, remote_iov, riovcnt, flags);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(copy_file_range, [](FEXCore::Core::InternalThreadState *Thread, int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags) -> uint64_t {
+      uint64_t Result = ::copy_file_range(fd_in, off_in, fd_out, off_out, len, flags);
       SYSCALL_ERRNO();
     });
   }

External/FEXCore/Source/Interface/HLE/Syscalls/FS.cpp

@@ -4,6 +4,9 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <sys/fanotify.h>
+#include <sys/mount.h>
+#include <sys/swap.h>
 #include <sys/syscall.h>
 #include <sys/types.h>
 #include <sys/vfs.h>
@@ -83,6 +86,29 @@ namespace FEXCore::HLE {
       SYSCALL_ERRNO();
     });
 
+    REGISTER_SYSCALL_IMPL(ustat, [](FEXCore::Core::InternalThreadState *Thread, dev_t dev, struct ustat *ubuf) -> uint64_t {
+      // Since version 2.28 of GLIBC it has stopped providing a wrapper for this syscall
+#ifdef SYS_ustat
+      uint64_t Result = syscall(SYS_ustat, dev, ubuf);
+      SYSCALL_ERRNO();
+#else
+      return -ENOSYS;
+#endif
+    });
+
+    /*
+      arg1 is one of: void, unsigned int fs_index, const char *fsname
+      arg2 is one of: void, char *buf
+    */
+    REGISTER_SYSCALL_IMPL(sysfs, [](FEXCore::Core::InternalThreadState *Thread, int option,  uint64_t arg1,  uint64_t arg2) -> uint64_t {
+#ifdef SYS_sysfs
+      uint64_t Result = syscall(SYS_sysfs, option, arg1, arg2);
+      SYSCALL_ERRNO();
+#else
+      return -ENOSYS;
+#endif
+    });
+
     REGISTER_SYSCALL_IMPL(statfs, [](FEXCore::Core::InternalThreadState *Thread, const char *path, struct statfs *buf) -> uint64_t {
       uint64_t Result = Thread->CTX->SyscallHandler->FM.Statfs(path, buf);
       SYSCALL_ERRNO();
@@ -103,11 +129,42 @@ namespace FEXCore::HLE {
     });*/
     REGISTER_SYSCALL_FORWARD_ERRNO(creat);
 
+    REGISTER_SYSCALL_IMPL(chroot, [](FEXCore::Core::InternalThreadState *Thread, const char *path) -> uint64_t {
+      uint64_t Result = ::chroot(path);
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL(sync, [](FEXCore::Core::InternalThreadState *Thread) -> uint64_t {
       sync();
       return 0; // always successful
     });
 
+    REGISTER_SYSCALL_IMPL(acct, [](FEXCore::Core::InternalThreadState *Thread, const char *filename) -> uint64_t {
+      uint64_t Result = ::acct(filename);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(mount, [](FEXCore::Core::InternalThreadState *Thread, 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(umount2, [](FEXCore::Core::InternalThreadState *Thread, const char *target, int flags) -> uint64_t {
+      uint64_t Result = ::umount2(target, flags);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(swapon, [](FEXCore::Core::InternalThreadState *Thread, const char *path, int swapflags) -> uint64_t {
+      uint64_t Result = ::swapon(path, swapflags);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(swapoff, [](FEXCore::Core::InternalThreadState *Thread, const char *path) -> uint64_t {
+      uint64_t Result = ::swapoff(path);
+      SYSCALL_ERRNO();
+    });
+
+
     /*
     REGISTER_SYSCALL_IMPL(syncfs, [](FEXCore::Core::InternalThreadState *Thread, int fd) -> uint64_t {
       SYSCALL_STUB(syncfs);
@@ -186,5 +243,14 @@ namespace FEXCore::HLE {
     });*/
     REGISTER_SYSCALL_FORWARD_ERRNO(fremovexattr);
 
+    REGISTER_SYSCALL_IMPL(fanotify_init, [](FEXCore::Core::InternalThreadState *Thread, unsigned int flags, unsigned int event_f_flags) -> uint64_t {
+      uint64_t Result = ::fanotify_init(flags, event_f_flags);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(fanotify_mark, [](FEXCore::Core::InternalThreadState *Thread, 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();
+    });
   }
 }

External/FEXCore/Source/Interface/HLE/Syscalls/IO.cpp

@@ -1,6 +1,10 @@
 #include "Interface/HLE/Syscalls.h"
 #include "Interface/HLE/x64/Syscalls.h"
 
+#include <linux/aio_abi.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
 namespace FEXCore::Core {
 struct InternalThreadState;
 }
@@ -8,9 +12,54 @@ struct InternalThreadState;
 namespace FEXCore::HLE {
 
   void RegisterIO() {
+    REGISTER_SYSCALL_IMPL(iopl, [](FEXCore::Core::InternalThreadState *Thread, int level) -> uint64_t {
+      // Just claim we don't have permission
+      return -EPERM;
+    });
+
     REGISTER_SYSCALL_IMPL(ioperm, [](FEXCore::Core::InternalThreadState *Thread, unsigned long from, unsigned long num, int turn_on) -> uint64_t {
-        // ioperm not available on our architecture
-        return -EPERM;
+      // ioperm not available on our architecture
+      return -EPERM;
+    });
+
+    REGISTER_SYSCALL_IMPL(io_setup, [](FEXCore::Core::InternalThreadState *Thread, unsigned nr_events, aio_context_t *ctx_idp) -> uint64_t {
+      uint64_t Result = ::syscall(SYS_io_setup, nr_events, ctx_idp);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(io_destroy, [](FEXCore::Core::InternalThreadState *Thread, aio_context_t ctx_id) -> uint64_t {
+      uint64_t Result = ::syscall(SYS_io_destroy, ctx_id);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(io_getevents, [](FEXCore::Core::InternalThreadState *Thread, aio_context_t ctx_id, long min_nr, long nr, struct io_event *events, struct timespec *timeout) -> uint64_t {
+      uint64_t Result = ::syscall(SYS_io_getevents, ctx_id, min_nr, nr, events, timeout);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(io_submit, [](FEXCore::Core::InternalThreadState *Thread, aio_context_t ctx_id, long nr, struct iocb **iocbpp) -> uint64_t {
+      uint64_t Result = ::syscall(SYS_io_submit, ctx_id, nr, iocbpp);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(io_cancel, [](FEXCore::Core::InternalThreadState *Thread, aio_context_t ctx_id, struct iocb *iocb, struct io_event *result) -> uint64_t {
+      uint64_t Result = ::syscall(SYS_io_cancel, ctx_id, iocb, result);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(ioprio_set, [](FEXCore::Core::InternalThreadState *Thread, int which, int who) -> uint64_t {
+      uint64_t Result = ::syscall(SYS_ioprio_set, which, who);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(ioprio_get, [](FEXCore::Core::InternalThreadState *Thread, int which, int who, int ioprio) -> uint64_t {
+      uint64_t Result = ::syscall(SYS_ioprio_get, which, who, ioprio);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(io_pgetevents, [](FEXCore::Core::InternalThreadState *Thread, aio_context_t ctx_id, long min_nr, long nr, struct io_event *events, struct timespec *timeout, const struct io_sigset  *usig) -> uint64_t {
+      uint64_t Result = ::syscall(SYS_io_pgetevents, ctx_id, min_nr, nr, events, timeout);
+      SYSCALL_ERRNO();
     });
   }
 }

External/FEXCore/Source/Interface/HLE/Syscalls/Info.cpp

@@ -1,7 +1,10 @@
+#include "Interface/Context/Context.h"
 #include "Interface/HLE/Syscalls.h"
 #include "Interface/HLE/x64/Syscalls.h"
 
 #include <cstring>
+#include <linux/kcmp.h>
+#include <linux/seccomp.h>
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -9,16 +12,15 @@
 #include <sys/capability.h>
 #include <sys/random.h>
 #include <sys/resource.h>
+#include <sys/syscall.h>
 #include <sys/sysinfo.h>
 #include <sys/utsname.h>
 #include <sys/klog.h>
+#include <unistd.h>
 
 #ifndef FEXCORE_VERSION
 #define FEXCORE_VERSION "1"
 #endif
-namespace FEXCore::Core {
-struct InternalThreadState;
-}
 
 namespace FEXCore::HLE {
 
@@ -32,6 +34,16 @@ namespace FEXCore::HLE {
       return 0;
     });
 
+    REGISTER_SYSCALL_IMPL(getrlimit, [](FEXCore::Core::InternalThreadState *Thread, int resource, struct rlimit *rlim) -> uint64_t {
+      uint64_t Result = ::getrlimit(resource, rlim);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(setrlimit, [](FEXCore::Core::InternalThreadState *Thread, int resource, const struct rlimit *rlim) -> uint64_t {
+      uint64_t Result = ::setrlimit(resource, rlim);
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL(getrusage, [](FEXCore::Core::InternalThreadState *Thread, int who, struct rusage *usage) -> uint64_t {
       uint64_t Result = ::getrusage(who, usage);
       SYSCALL_ERRNO();
@@ -61,5 +73,35 @@ namespace FEXCore::HLE {
       uint64_t Result = ::capset(hdrp, datap);
       SYSCALL_ERRNO();
     });
+
+    REGISTER_SYSCALL_IMPL(getcpu, [](FEXCore::Core::InternalThreadState *Thread, unsigned *cpu, unsigned *node, struct getcpu_cache *tcache) -> uint64_t {
+      uint32_t LocalCPU{};
+      uint32_t LocalNode{};
+      // tcache is ignored
+      uint64_t Result = ::syscall(SYS_getcpu, cpu ? &LocalCPU : nullptr, node ? &LocalNode : nullptr, nullptr);
+      if (Result == 0) {
+        if (cpu) {
+          // Ensure we don't return a number over our number of emulated cores
+          *cpu = LocalCPU % Thread->CTX->Config.EmulatedCPUCores;
+        }
+
+        if (node) {
+          // Just claim we are part of node zero
+          *node = 0;
+        }
+      }
+      SYSCALL_ERRNO();
+    });
+
+    //compare  two  processes  to determine if they share a kernel resource
+    REGISTER_SYSCALL_IMPL(kcmp, [](FEXCore::Core::InternalThreadState *Thread, pid_t pid1, pid_t pid2, int type, unsigned long idx1, unsigned long idx2) -> uint64_t {
+      uint64_t Result = ::syscall(SYS_kcmp, pid1, pid2, type, idx1, idx2);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(seccomp, [](FEXCore::Core::InternalThreadState *Thread, unsigned int operation, unsigned int flags, void *args) -> uint64_t {
+      uint64_t Result = ::syscall(SYS_seccomp, operation, flags, args);
+      SYSCALL_ERRNO();
+    });
   }
 }

External/FEXCore/Source/Interface/HLE/Syscalls/Key.cpp

@@ -0,0 +1,47 @@
+#include "Interface/HLE/Syscalls.h"
+#include "Interface/HLE/x64/Syscalls.h"
+
+#include <sys/mman.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+namespace FEXCore::Core {
+struct InternalThreadState;
+}
+
+namespace FEXCore::HLE {
+  void RegisterKey() {
+    REGISTER_SYSCALL_IMPL(add_key, [](FEXCore::Core::InternalThreadState *Thread, const char *type, const char *description, const void *payload, size_t plen, int32_t /*key_serial_t*/ keyring) -> uint64_t {
+      uint64_t Result = syscall(SYS_add_key, type, description, payload, plen, keyring);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(request_key, [](FEXCore::Core::InternalThreadState *Thread, const char *type, const char *description, const char *callout_info, int32_t /*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(keyctl, [](FEXCore::Core::InternalThreadState *Thread, 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(pkey_mprotect, [](FEXCore::Core::InternalThreadState *Thread, void *addr, size_t len, int prot, int pkey) -> uint64_t {
+      // Added in Linux 4.9
+      uint64_t Result = ::pkey_mprotect(addr, len, prot, pkey);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(pkey_alloc, [](FEXCore::Core::InternalThreadState *Thread, unsigned int flags, unsigned int access_rights) -> uint64_t {
+      // Added in Linux 4.9
+      uint64_t Result = ::pkey_alloc(flags, access_rights);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(pkey_free, [](FEXCore::Core::InternalThreadState *Thread, int pkey) -> uint64_t {
+      // Added in Linux 4.9
+      uint64_t Result = ::pkey_free(pkey);
+      SYSCALL_ERRNO();
+    });
+  }
+}

External/FEXCore/Source/Interface/HLE/Syscalls/Memory.cpp

@@ -87,6 +87,17 @@ namespace FEXCore::HLE {
       SYSCALL_ERRNO();
     });
 
+    REGISTER_SYSCALL_IMPL(remap_file_pages, [](FEXCore::Core::InternalThreadState *Thread, 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(mbind, [](FEXCore::Core::InternalThreadState *Thread, void *addr, unsigned long len, int mode, const unsigned long *nodemask, unsigned long maxnode, unsigned flags) -> uint64_t {
+      uint64_t Result = ::mbind(addr, len, mode, nodemask, maxnode, flags);
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL(get_mempolicy, [](FEXCore::Core::InternalThreadState *Thread, int *mode, unsigned long *nodemask, unsigned long maxnode, void *addr, unsigned long flags) -> uint64_t {
       uint64_t Result = ::get_mempolicy(mode, nodemask, maxnode, addr, flags);
       SYSCALL_ERRNO();
@@ -97,6 +108,16 @@ namespace FEXCore::HLE {
       SYSCALL_ERRNO();
     });
 
+    REGISTER_SYSCALL_IMPL(migrate_pages, [](FEXCore::Core::InternalThreadState *Thread, int pid, unsigned long maxnode, const unsigned long *old_nodes, const unsigned long *new_nodes) -> uint64_t {
+      uint64_t Result = ::migrate_pages(pid, maxnode, old_nodes, new_nodes);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(move_pages, [](FEXCore::Core::InternalThreadState *Thread, int pid, unsigned long count, void **pages, const int *nodes, int *status, int flags) -> uint64_t {
+      uint64_t Result = ::move_pages(pid, count, pages, nodes, status, flags);
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL(membarrier, [](FEXCore::Core::InternalThreadState *Thread, int cmd, int flags) -> uint64_t {
         uint64_t Result = syscall(SYS_membarrier, cmd, flags);
         SYSCALL_ERRNO();

External/FEXCore/Source/Interface/HLE/Syscalls/Msg.cpp

@@ -0,0 +1,68 @@
+#include "Interface/HLE/Syscalls.h"
+#include "Interface/HLE/x64/Syscalls.h"
+
+#include <mqueue.h>
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/msg.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+namespace FEXCore::Core {
+struct InternalThreadState;
+}
+
+namespace FEXCore::HLE {
+  void RegisterMsg() {
+    REGISTER_SYSCALL_IMPL(msgget, [](FEXCore::Core::InternalThreadState *Thread, key_t key, int msgflg) -> uint64_t {
+      uint64_t Result = ::msgget(key, msgflg);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(msgsnd, [](FEXCore::Core::InternalThreadState *Thread, 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(msgrcv, [](FEXCore::Core::InternalThreadState *Thread, 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(msgctl, [](FEXCore::Core::InternalThreadState *Thread, int msqid, int cmd, struct msqid_ds *buf) -> uint64_t {
+      uint64_t Result = ::msgctl(msqid, cmd, buf);
+      SYSCALL_ERRNO();
+    });
+
+    // last two parameters are optional
+    REGISTER_SYSCALL_IMPL(mq_open, [](FEXCore::Core::InternalThreadState *Thread, const char *name, int oflag, mode_t mode, struct mq_attr *attr) -> uint64_t {
+      uint64_t Result = ::mq_open(name, oflag, mode, attr);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(mq_unlink, [](FEXCore::Core::InternalThreadState *Thread, const char *name) -> uint64_t {
+      uint64_t Result = ::mq_unlink(name);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(mq_timedsend, [](FEXCore::Core::InternalThreadState *Thread, mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abs_timeout) -> uint64_t {
+      uint64_t Result = ::mq_timedsend(mqdes, msg_ptr, msg_len, msg_prio, abs_timeout);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(mq_timedreceive, [](FEXCore::Core::InternalThreadState *Thread, mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abs_timeout) -> uint64_t {
+      uint64_t Result = ::mq_timedreceive(mqdes, msg_ptr, msg_len, msg_prio, abs_timeout);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(mq_notify, [](FEXCore::Core::InternalThreadState *Thread, mqd_t mqdes, const struct sigevent *sevp) -> uint64_t {
+      uint64_t Result = ::mq_notify(mqdes, sevp);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(mq_getsetattr, [](FEXCore::Core::InternalThreadState *Thread, mqd_t mqdes, struct mq_attr *newattr, struct mq_attr *oldattr) -> uint64_t {
+      uint64_t Result = ::syscall(SYS_mq_getsetattr, mqdes, newattr, oldattr);
+      SYSCALL_ERRNO();
+    });
+  }
+}

External/FEXCore/Source/Interface/HLE/Syscalls/NotImplemented.cpp

@@ -14,6 +14,14 @@ struct InternalThreadState;
   return -ENOSYS; \
 });
 
+#define REGISTER_SYSCALL_NO_PERM(name) REGISTER_SYSCALL_IMPL(name, [](FEXCore::Core::InternalThreadState *Thread) -> uint64_t { \
+  return -EPERM; \
+});
+
+#define REGISTER_SYSCALL_NO_ACCESS(name) REGISTER_SYSCALL_IMPL(name, [](FEXCore::Core::InternalThreadState *Thread) -> uint64_t { \
+  return -EACCES; \
+});
+
 namespace FEXCore::HLE {
 
   // these are removed/not implemented in the linux kernel we present
@@ -23,7 +31,7 @@ namespace FEXCore::HLE {
       REGISTER_SYSCALL_NOT_IMPL(create_module);
       REGISTER_SYSCALL_NOT_IMPL(get_kernel_syms);
       REGISTER_SYSCALL_NOT_IMPL(query_module);
-      REGISTER_SYSCALL_NOT_IMPL(nfsservctl);
+      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);
@@ -34,6 +42,21 @@ namespace FEXCore::HLE {
       REGISTER_SYSCALL_NOT_IMPL(epoll_ctl_old);
       REGISTER_SYSCALL_NOT_IMPL(epoll_wait_old);
       REGISTER_SYSCALL_NOT_IMPL(vserver);
-      REGISTER_SYSCALL_NOT_IMPL(_sysctl);
+      REGISTER_SYSCALL_NOT_IMPL(_sysctl); // Was removed in Linux 5.5
+
+      REGISTER_SYSCALL_NO_PERM(vhangup);
+      REGISTER_SYSCALL_NO_PERM(pivot_root);
+      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(kexec_file_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);
   }
-}
+}

External/FEXCore/Source/Interface/HLE/Syscalls/Signals.cpp

@@ -6,6 +6,8 @@
 #include <FEXCore/Core/X86Enums.h>
 
 #include <signal.h>
+#include <sys/syscall.h>
+#include <unistd.h>
 
 namespace FEXCore::HLE {
 
@@ -29,5 +31,10 @@ namespace FEXCore::HLE {
     REGISTER_SYSCALL_IMPL(rt_sigsuspend, [](FEXCore::Core::InternalThreadState *Thread, uint64_t *unewset, size_t sigsetsize) -> uint64_t {
       return Thread->CTX->SignalDelegation.GuestSigSuspend(unewset, sigsetsize);
     });
+
+    REGISTER_SYSCALL_IMPL(userfaultfd, [](FEXCore::Core::InternalThreadState *Thread, int flags) -> uint64_t {
+      uint64_t Result = ::syscall(SYS_userfaultfd, flags);
+      SYSCALL_ERRNO();
+    });
   }
 }

External/FEXCore/Source/Interface/HLE/Syscalls/Socket.cpp

@@ -12,7 +12,7 @@ struct InternalThreadState;
 namespace FEXCore::HLE {
 
   void RegisterSocket() {
-      
+
     REGISTER_SYSCALL_IMPL(socket, [](FEXCore::Core::InternalThreadState *Thread, int domain, int type, int protocol) -> uint64_t {
       uint64_t Result = ::socket(domain, type, protocol);
       SYSCALL_ERRNO();
@@ -93,9 +93,15 @@ namespace FEXCore::HLE {
       SYSCALL_ERRNO();
     });
 
+    REGISTER_SYSCALL_IMPL(recvmmsg, [](FEXCore::Core::InternalThreadState *Thread, int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags, struct timespec *timeout) -> uint64_t {
+      uint64_t Result = ::recvmmsg(sockfd, msgvec, vlen, flags, timeout);
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL(sendmmsg, [](FEXCore::Core::InternalThreadState *Thread, int sockfd, struct mmsghdr *msgvec, uint32_t vlen, int flags) -> uint64_t {
       uint64_t Result = ::sendmmsg(sockfd, msgvec, vlen, flags);
       SYSCALL_ERRNO();
     });
+
   }
 }

External/FEXCore/Source/Interface/HLE/Syscalls/Stubs.cpp

@@ -34,52 +34,10 @@ namespace FEXCore::HLE {
       SYSCALL_STUB(rt_sigreturn);
     });
 
-    REGISTER_SYSCALL_IMPL(pause, [](FEXCore::Core::InternalThreadState *Thread) -> uint64_t {
-      SYSCALL_STUB(pause);
-    });
-
-    REGISTER_SYSCALL_IMPL(sendfile, [](FEXCore::Core::InternalThreadState *Thread, int out_fd, int in_fd, off_t *offset, size_t count) -> uint64_t {
-      SYSCALL_STUB(sendfile);
-    });
-
-    REGISTER_SYSCALL_IMPL(msgget, [](FEXCore::Core::InternalThreadState *Thread, key_t key, int msgflg) -> uint64_t {
-      SYSCALL_STUB(msgget);
-    });
-
-    REGISTER_SYSCALL_IMPL(msgsnd, [](FEXCore::Core::InternalThreadState *Thread, int msqid, const void *msgp, size_t msgsz, int msgflg) -> uint64_t {
-      SYSCALL_STUB(msgsnd);
-    });
-
-    REGISTER_SYSCALL_IMPL(msgrcv, [](FEXCore::Core::InternalThreadState *Thread, int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg) -> uint64_t {
-      SYSCALL_STUB(msgrcv);
-    });
-
-    REGISTER_SYSCALL_IMPL(msgctl, [](FEXCore::Core::InternalThreadState *Thread, int msqid, int cmd, struct msqid_ds *buf) -> uint64_t {
-      SYSCALL_STUB(msgctl);
-    });
-
-    REGISTER_SYSCALL_IMPL(getrlimit, [](FEXCore::Core::InternalThreadState *Thread, int resource, struct rlimit *rlim) -> uint64_t {
-      SYSCALL_STUB(getrlimit);
-    });
-
-    REGISTER_SYSCALL_IMPL(times, [](FEXCore::Core::InternalThreadState *Thread, struct tms *buf) -> uint64_t {
-      SYSCALL_STUB(times);
-    });
-
     REGISTER_SYSCALL_IMPL(ptrace, [](FEXCore::Core::InternalThreadState *Thread, int /*enum __ptrace_request*/ request, pid_t pid, void *addr, void *data) -> uint64_t {
       SYSCALL_STUB(ptrace);
     });
 
-
-
-    REGISTER_SYSCALL_IMPL(getgroups, [](FEXCore::Core::InternalThreadState *Thread, int size, gid_t list[]) -> uint64_t {
-      SYSCALL_STUB(getgroups);
-    });
-
-    REGISTER_SYSCALL_IMPL(setgroups, [](FEXCore::Core::InternalThreadState *Thread, size_t size, const gid_t *list) -> uint64_t {
-      SYSCALL_STUB(setgroups);
-    });
-
     REGISTER_SYSCALL_IMPL(rt_sigtimedwait, [](FEXCore::Core::InternalThreadState *Thread, sigset_t *set, const struct timespec*, size_t sigsetsize) -> uint64_t {
       SYSCALL_STUB(rt_sigtimedwait);
     });
@@ -87,267 +45,15 @@ namespace FEXCore::HLE {
     REGISTER_SYSCALL_IMPL(rt_sigqueueinfo, [](FEXCore::Core::InternalThreadState *Thread, pid_t pid, int sig, siginfo_t *uinfo) -> uint64_t {
       SYSCALL_STUB(rt_sigqueueinfo);
     });
-    REGISTER_SYSCALL_IMPL(utime, [](FEXCore::Core::InternalThreadState *Thread, char* filename, const struct utimbuf* times) -> uint64_t {
-      SYSCALL_STUB(utime);
-    });
-
-    REGISTER_SYSCALL_IMPL(ustat, [](FEXCore::Core::InternalThreadState *Thread, dev_t dev, struct ustat *ubuf) -> uint64_t {
-      SYSCALL_STUB(ustat);
-    });
-
-    /*
-      arg1 is one of: void, unsigned int fs_index, const char *fsname
-      arg2 is one of: void, char *buf
-    */
-    REGISTER_SYSCALL_IMPL(sysfs, [](FEXCore::Core::InternalThreadState *Thread, int option,  uint64_t arg1,  uint64_t arg2) -> uint64_t {
-      SYSCALL_STUB(sysfs);
-    });
-
-    REGISTER_SYSCALL_IMPL(vhangup, [](FEXCore::Core::InternalThreadState *Thread) -> uint64_t {
-      SYSCALL_STUB(vhangup);
-    });
 
     REGISTER_SYSCALL_IMPL(modify_ldt, [](FEXCore::Core::InternalThreadState *Thread, int func, void *ptr, unsigned long bytecount) -> uint64_t {
       SYSCALL_STUB(modify_ldt);
     });
 
-    REGISTER_SYSCALL_IMPL(pivot_root, [](FEXCore::Core::InternalThreadState *Thread, const char *new_root, const char *put_old) -> uint64_t {
-      SYSCALL_STUB(pivot_root);
-    });
-
-    REGISTER_SYSCALL_IMPL(adjtimex, [](FEXCore::Core::InternalThreadState *Thread, struct timex *buf) -> uint64_t {
-      SYSCALL_STUB(adjtimex);
-    });
-
-    REGISTER_SYSCALL_IMPL(setrlimit, [](FEXCore::Core::InternalThreadState *Thread, int resource, const struct rlimit *rlim) -> uint64_t {
-      SYSCALL_STUB(setrlimit);
-    });
-
-    REGISTER_SYSCALL_IMPL(chroot, [](FEXCore::Core::InternalThreadState *Thread, const char *path) -> uint64_t {
-      SYSCALL_STUB(chroot);
-    });
-
-    REGISTER_SYSCALL_IMPL(acct, [](FEXCore::Core::InternalThreadState *Thread, const char *filename) -> uint64_t {
-      SYSCALL_STUB(acct);
-    });
-
-    REGISTER_SYSCALL_IMPL(settimeofday, [](FEXCore::Core::InternalThreadState *Thread, const struct timeval *tv, const struct timezone *tz) -> uint64_t {
-      SYSCALL_STUB(settimeofday);
-    });
-
-    REGISTER_SYSCALL_IMPL(mount, [](FEXCore::Core::InternalThreadState *Thread, const char *source, const char *target, const char *filesystemtype, unsigned long mountflags, const void *data) -> uint64_t {
-      SYSCALL_STUB(mount);
-    });
-
-    REGISTER_SYSCALL_IMPL(umount2, [](FEXCore::Core::InternalThreadState *Thread, const char *target, int flags) -> uint64_t {
-      SYSCALL_STUB(umount2);
-    });
-
-    REGISTER_SYSCALL_IMPL(swapon, [](FEXCore::Core::InternalThreadState *Thread, const char *path, int swapflags) -> uint64_t {
-      SYSCALL_STUB(swapon);
-    });
-
-    REGISTER_SYSCALL_IMPL(swapoff, [](FEXCore::Core::InternalThreadState *Thread, const char *path) -> uint64_t {
-      SYSCALL_STUB(swapoff);
-    });
-
-    REGISTER_SYSCALL_IMPL(reboot, [](FEXCore::Core::InternalThreadState *Thread, int magic, int magic2, int cmd, void *arg) -> uint64_t {
-      SYSCALL_STUB(reboot);
-    });
-
-    REGISTER_SYSCALL_IMPL(sethostname, [](FEXCore::Core::InternalThreadState *Thread, const char *name, size_t len) -> uint64_t {
-      SYSCALL_STUB(sethostname);
-    });
-
-    REGISTER_SYSCALL_IMPL(setdomainname, [](FEXCore::Core::InternalThreadState *Thread, const char *name, size_t len) -> uint64_t {
-      SYSCALL_STUB(setdomainname);
-    });
-
-    REGISTER_SYSCALL_IMPL(iopl, [](FEXCore::Core::InternalThreadState *Thread, int level) -> uint64_t {
-      SYSCALL_STUB(iopl);
-    });
-
-    REGISTER_SYSCALL_IMPL(init_module, [](FEXCore::Core::InternalThreadState *Thread, void *module_image, unsigned long len, const char *param_values) -> uint64_t {
-      SYSCALL_STUB(init_module);
-    });
-
-    REGISTER_SYSCALL_IMPL(delete_module, [](FEXCore::Core::InternalThreadState *Thread, const char *name, int flags) -> uint64_t {
-      SYSCALL_STUB(delete_module);
-    });
-
-    REGISTER_SYSCALL_IMPL(quotactl, [](FEXCore::Core::InternalThreadState *Thread, int cmd, const char *special, int id, caddr_t addr) -> uint64_t {
-      SYSCALL_STUB(quotactl);
-    });
-
-    REGISTER_SYSCALL_IMPL(readahead, [](FEXCore::Core::InternalThreadState *Thread, int fd, off64_t offset, size_t count) -> uint64_t {
-      SYSCALL_STUB(readahead);
-    });
-
-    REGISTER_SYSCALL_IMPL(io_setup, [](FEXCore::Core::InternalThreadState *Thread, unsigned nr_events, aio_context_t *ctx_idp) -> uint64_t {
-      SYSCALL_STUB(io_setup);
-    });
-
-    REGISTER_SYSCALL_IMPL(io_destroy, [](FEXCore::Core::InternalThreadState *Thread, aio_context_t ctx_id) -> uint64_t {
-      SYSCALL_STUB(io_destroy);
-    });
-
-    REGISTER_SYSCALL_IMPL(io_getevents, [](FEXCore::Core::InternalThreadState *Thread, aio_context_t ctx_id, long min_nr, long nr, struct io_event *events, struct timespec *timeout) -> uint64_t {
-      SYSCALL_STUB(io_getevents);
-    });
-
-    REGISTER_SYSCALL_IMPL(io_submit, [](FEXCore::Core::InternalThreadState *Thread, aio_context_t ctx_id, long nr, struct iocb **iocbpp) -> uint64_t {
-      SYSCALL_STUB(io_submit);
-    });
-
-    REGISTER_SYSCALL_IMPL(io_cancel, [](FEXCore::Core::InternalThreadState *Thread, aio_context_t ctx_id, struct iocb *iocb, struct io_event *result) -> uint64_t {
-      SYSCALL_STUB(io_cancel);
-    });
-
-    REGISTER_SYSCALL_IMPL(lookup_dcookie, [](FEXCore::Core::InternalThreadState *Thread, uint64_t cookie, char *buffer, size_t len) -> uint64_t {
-      SYSCALL_STUB(lookup_dcookie);
-    });
-
-    REGISTER_SYSCALL_IMPL(remap_file_pages, [](FEXCore::Core::InternalThreadState *Thread, void *addr, size_t size, int prot, size_t pgoff, int flags) -> uint64_t {
-      SYSCALL_STUB(remap_file_pages);
-    });
-
     REGISTER_SYSCALL_IMPL(restart_syscall, [](FEXCore::Core::InternalThreadState *Thread) -> uint64_t {
       SYSCALL_STUB(restart_syscall);
     });
 
-    REGISTER_SYSCALL_IMPL(clock_settime, [](FEXCore::Core::InternalThreadState *Thread, clockid_t clockid, const struct timespec *tp) -> uint64_t {
-      SYSCALL_STUB(clock_settime);
-    });
-
-    REGISTER_SYSCALL_IMPL(utimes, [](FEXCore::Core::InternalThreadState *Thread, const char *filename, const struct timeval times[2]) -> uint64_t {
-      SYSCALL_STUB(utimes);
-    });
-
-    REGISTER_SYSCALL_IMPL(mbind, [](FEXCore::Core::InternalThreadState *Thread, void *addr, unsigned long len, int mode, const unsigned long *nodemask, unsigned long maxnode, unsigned flags) -> uint64_t {
-      SYSCALL_STUB(mbind);
-    });
-
-    // last two parameters are optional
-    REGISTER_SYSCALL_IMPL(mq_open, [](FEXCore::Core::InternalThreadState *Thread, const char *name, int oflag, mode_t mode, struct mq_attr *attr) -> uint64_t {
-      SYSCALL_STUB(mq_open);
-    });
-
-    REGISTER_SYSCALL_IMPL(mq_unlink, [](FEXCore::Core::InternalThreadState *Thread, const char *name) -> uint64_t {
-      SYSCALL_STUB(mq_unlink);
-    });
-
-    REGISTER_SYSCALL_IMPL(mq_timedsend, [](FEXCore::Core::InternalThreadState *Thread, mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abs_timeout) -> uint64_t {
-      SYSCALL_STUB(mq_timedsend);
-    });
-
-    REGISTER_SYSCALL_IMPL(mq_timedreceive, [](FEXCore::Core::InternalThreadState *Thread, mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abs_timeout) -> uint64_t {
-      SYSCALL_STUB(mq_timedreceive);
-    });
-
-    REGISTER_SYSCALL_IMPL(mq_notify, [](FEXCore::Core::InternalThreadState *Thread, mqd_t mqdes, const struct sigevent *sevp) -> uint64_t {
-      SYSCALL_STUB(mq_notify);
-    });
-
-    REGISTER_SYSCALL_IMPL(mq_getsetattr, [](FEXCore::Core::InternalThreadState *Thread, mqd_t mqdes, struct mq_attr *newattr, struct mq_attr *oldattr) -> uint64_t {
-      SYSCALL_STUB(mq_getsetattr);
-    });
-
-    REGISTER_SYSCALL_IMPL(kexec_load, [](FEXCore::Core::InternalThreadState *Thread, unsigned long entry, unsigned long nr_segments, struct kexec_segment *segments, unsigned long flags) -> uint64_t {
-      SYSCALL_STUB(kexec_load);
-    });
-
-    REGISTER_SYSCALL_IMPL(waitid, [](FEXCore::Core::InternalThreadState *Thread, int /*idtype_t*/ idtype, id_t id, siginfo_t *infop, int options) -> uint64_t {
-      SYSCALL_STUB(waitid);
-    });
-
-    REGISTER_SYSCALL_IMPL(add_key, [](FEXCore::Core::InternalThreadState *Thread, const char *type, const char *description, const void *payload, size_t plen, int32_t /*key_serial_t*/ keyring) -> uint64_t {
-      SYSCALL_STUB(add_key);
-    });
-
-    REGISTER_SYSCALL_IMPL(request_key, [](FEXCore::Core::InternalThreadState *Thread, const char *type, const char *description, const char *callout_info, int32_t /*key_serial_t*/ dest_keyring) -> uint64_t {
-      SYSCALL_STUB(request_key);
-    });
-
-    REGISTER_SYSCALL_IMPL(keyctl, [](FEXCore::Core::InternalThreadState *Thread, int operation, uint64_t arg2, uint64_t arg3, uint64_t arg4, uint64_t arg5) -> uint64_t {
-      SYSCALL_STUB(keyctl);
-    });
-
-    REGISTER_SYSCALL_IMPL(ioprio_set, [](FEXCore::Core::InternalThreadState *Thread, int which, int who) -> uint64_t {
-      SYSCALL_STUB(ioprio_set);
-    });
-
-    REGISTER_SYSCALL_IMPL(ioprio_get, [](FEXCore::Core::InternalThreadState *Thread, int which, int who, int ioprio) -> uint64_t {
-      SYSCALL_STUB(ioprio_get);
-    });
-
-    REGISTER_SYSCALL_IMPL(migrate_pages, [](FEXCore::Core::InternalThreadState *Thread, int pid, unsigned long maxnode, const unsigned long *old_nodes, const unsigned long *new_nodes) -> uint64_t {
-      SYSCALL_STUB(migrate_pages);
-    });
-
-    REGISTER_SYSCALL_IMPL(mkdirat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, mode_t mode) -> uint64_t {
-      SYSCALL_STUB(mkdirat);
-    });
-
-    REGISTER_SYSCALL_IMPL(mknodat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, mode_t mode, dev_t dev) -> uint64_t {
-      SYSCALL_STUB(mknodat);
-    });
-
-    REGISTER_SYSCALL_IMPL(fchownat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, uid_t owner, gid_t group, int flags) -> uint64_t {
-      SYSCALL_STUB(fchownat);
-    });
-
-    REGISTER_SYSCALL_IMPL(futimesat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, const struct timeval times[2]) -> uint64_t {
-      SYSCALL_STUB(futimesat);
-    });
-
-    REGISTER_SYSCALL_IMPL(unlinkat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, int flags) -> uint64_t {
-      SYSCALL_STUB(unlinkat);
-    });
-
-    REGISTER_SYSCALL_IMPL(renameat, [](FEXCore::Core::InternalThreadState *Thread, int olddirfd, const char *oldpath, int newdirfd, const char *newpath) -> uint64_t {
-      SYSCALL_STUB(renameat);
-    });
-
-    REGISTER_SYSCALL_IMPL(linkat, [](FEXCore::Core::InternalThreadState *Thread, int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags) -> uint64_t {
-      SYSCALL_STUB(linkat);
-    });
-
-    REGISTER_SYSCALL_IMPL(symlinkat, [](FEXCore::Core::InternalThreadState *Thread, const char *target, int newdirfd, const char *linkpath) -> uint64_t {
-      SYSCALL_STUB(symlinkat);
-    });
-
-    REGISTER_SYSCALL_IMPL(fchmodat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, mode_t mode, int flags) -> uint64_t {
-      SYSCALL_STUB(fchmodat);
-    });
-
-    REGISTER_SYSCALL_IMPL(unshare, [](FEXCore::Core::InternalThreadState *Thread, int flags) -> uint64_t {
-      SYSCALL_STUB(unshare);
-    });
-
-    REGISTER_SYSCALL_IMPL(splice, [](FEXCore::Core::InternalThreadState *Thread, int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags) -> uint64_t {
-      SYSCALL_STUB(splice);
-    });
-
-    REGISTER_SYSCALL_IMPL(tee, [](FEXCore::Core::InternalThreadState *Thread, int fd_in, int fd_out, size_t len, unsigned int flags) -> uint64_t {
-      SYSCALL_STUB(tee);
-    });
-
-    REGISTER_SYSCALL_IMPL(sync_file_range, [](FEXCore::Core::InternalThreadState *Thread, int fd, off64_t offset, off64_t nbytes, unsigned int flags) -> uint64_t {
-      SYSCALL_STUB(sync_file_range);
-    });
-
-    REGISTER_SYSCALL_IMPL(vmsplice, [](FEXCore::Core::InternalThreadState *Thread, int fd, const struct iovec *iov, unsigned long nr_segs, unsigned int flags) -> uint64_t {
-      SYSCALL_STUB(vmsplice);
-    });
-
-    REGISTER_SYSCALL_IMPL(move_pages, [](FEXCore::Core::InternalThreadState *Thread, int pid, unsigned long count, void **pages, const int *nodes, int *status, int flags) -> uint64_t {
-      SYSCALL_STUB(move_pages);
-    });
-
-    REGISTER_SYSCALL_IMPL(utimensat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, const struct timespec times[2], int flags) -> uint64_t {
-      SYSCALL_STUB(utimensat);
-    });
-
     REGISTER_SYSCALL_IMPL(signalfd, [](FEXCore::Core::InternalThreadState *Thread, int fd, const sigset_t *mask, size_t sizemask) -> uint64_t {
       SYSCALL_STUB(signalfd);
     });
@@ -356,116 +62,15 @@ namespace FEXCore::HLE {
       SYSCALL_STUB(signalfd4);
     });
 
-    REGISTER_SYSCALL_IMPL(preadv, [](FEXCore::Core::InternalThreadState *Thread, int fd, const struct iovec *iov, int iovcnt, off_t offset) -> uint64_t {
-      SYSCALL_STUB(preadv);
-    });
-
-    REGISTER_SYSCALL_IMPL(pwritev, [](FEXCore::Core::InternalThreadState *Thread, int fd, const struct iovec *iov, int iovcnt, off_t offset) -> uint64_t {
-      SYSCALL_STUB(pwritev);
-    });
-
     REGISTER_SYSCALL_IMPL(rt_tgsigqueueinfo, [](FEXCore::Core::InternalThreadState *Thread, pid_t tgid, pid_t tid, int sig, siginfo_t *info) -> uint64_t {
       SYSCALL_STUB(rt_tgsigqueueinfo);
     });
 
-    REGISTER_SYSCALL_IMPL(perf_event_open, [](FEXCore::Core::InternalThreadState *Thread, struct perf_event_attr *attr, pid_t pid, int cpu, int group_fd, unsigned long flags) -> uint64_t {
-      SYSCALL_STUB(perf_event_open);
-    });
-
-    REGISTER_SYSCALL_IMPL(recvmmsg, [](FEXCore::Core::InternalThreadState *Thread, int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags, struct timespec *timeout) -> uint64_t {
-      SYSCALL_STUB(recvmmsg);
-    });
-
-    REGISTER_SYSCALL_IMPL(fanotify_init, [](FEXCore::Core::InternalThreadState *Thread, unsigned int flags, unsigned int event_f_flags) -> uint64_t {
-      SYSCALL_STUB(fanotify_init);
-    });
-
-    REGISTER_SYSCALL_IMPL(fanotify_mark, [](FEXCore::Core::InternalThreadState *Thread, int fanotify_fd, unsigned int flags, uint64_t mask, int dirfd, const char *pathname) -> uint64_t {
-      SYSCALL_STUB(fanotify_mark);
-    });
-
-    REGISTER_SYSCALL_IMPL(clock_adjtime, [](FEXCore::Core::InternalThreadState *Thread, clockid_t clk_id, struct timex *buf) -> uint64_t {
-      SYSCALL_STUB(clock_adjtime);
-    });
-
-    REGISTER_SYSCALL_IMPL(setns, [](FEXCore::Core::InternalThreadState *Thread, int fd, int nstype) -> uint64_t {
-      SYSCALL_STUB(setns);
-    });
-
-    REGISTER_SYSCALL_IMPL(getcpu, [](FEXCore::Core::InternalThreadState *Thread, unsigned *cpu, unsigned *node, struct getcpu_cache *tcache) -> uint64_t {
-      SYSCALL_STUB(getcpu);
-    });
-
-    REGISTER_SYSCALL_IMPL(process_vm_readv, [](FEXCore::Core::InternalThreadState *Thread, pid_t pid, const struct iovec *local_iov, unsigned long liovcnt, const struct iovec *remote_iov, unsigned long riovcnt, unsigned long flags) -> uint64_t {
-      SYSCALL_STUB(process_vm_readv);
-    });
-
-    REGISTER_SYSCALL_IMPL(process_vm_writev, [](FEXCore::Core::InternalThreadState *Thread, pid_t pid, const struct iovec *local_iov, unsigned long liovcnt, const struct iovec *remote_iov, unsigned long riovcnt, unsigned long flags) -> uint64_t {
-      SYSCALL_STUB(process_vm_writev);
-    });
-
-    //compare  two  processes  to determine if they share a kernel resource
-    REGISTER_SYSCALL_IMPL(kcmp, [](FEXCore::Core::InternalThreadState *Thread, pid_t pid1, pid_t pid2, int type, unsigned long idx1, unsigned long idx2) -> uint64_t {
-      SYSCALL_STUB(kcmp);
-    });
-
-    REGISTER_SYSCALL_IMPL(finit_module, [](FEXCore::Core::InternalThreadState *Thread, int fd, const char *param_values, int flags) -> uint64_t {
-      SYSCALL_STUB(finit_module);
-    });
-
-    REGISTER_SYSCALL_IMPL(renameat2, [](FEXCore::Core::InternalThreadState *Thread, int olddirfd, const char *oldpath, int newdirfd, const char *newpath, unsigned int flags) -> uint64_t {
-      SYSCALL_STUB(renameat2);
-    });
-
-    REGISTER_SYSCALL_IMPL(seccomp, [](FEXCore::Core::InternalThreadState *Thread, unsigned int operation, unsigned int flags, void *args) -> uint64_t {
-      SYSCALL_STUB(seccomp);
-    });
-
-    REGISTER_SYSCALL_IMPL(kexec_file_load, [](FEXCore::Core::InternalThreadState *Thread, int kernel_fd, int initrd_fd, unsigned long cmdline_len, const char *cmdline, unsigned long flags) -> uint64_t {
-      SYSCALL_STUB(kexec_file_load);
-    });
-
-    REGISTER_SYSCALL_IMPL(bpf, [](FEXCore::Core::InternalThreadState *Thread, int cmd, union bpf_attr *attr, unsigned int size) -> uint64_t {
-      SYSCALL_STUB(bpf);
-    });
-
     // execute program relative to a directory file descriptor
     REGISTER_SYSCALL_IMPL(execveat, [](FEXCore::Core::InternalThreadState *Thread, int dirfd, const char *pathname, char *const argv[], char *const envp[], int flags) -> uint64_t {
       SYSCALL_STUB(execveat);
     });
 
-    REGISTER_SYSCALL_IMPL(userfaultfd, [](FEXCore::Core::InternalThreadState *Thread, int flags) -> uint64_t {
-      SYSCALL_STUB(userfaultfd);
-    });
-
-    REGISTER_SYSCALL_IMPL(copy_file_range, [](FEXCore::Core::InternalThreadState *Thread, int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags) -> uint64_t {
-      SYSCALL_STUB(copy_file_range);
-    });
-
-    REGISTER_SYSCALL_IMPL(preadv2, [](FEXCore::Core::InternalThreadState *Thread, int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) -> uint64_t {
-      SYSCALL_STUB(preadv2);
-    });
-
-    REGISTER_SYSCALL_IMPL(pwritev2, [](FEXCore::Core::InternalThreadState *Thread, int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) -> uint64_t {
-      SYSCALL_STUB(pwritev2);
-    });
-
-    REGISTER_SYSCALL_IMPL(pkey_mprotect, [](FEXCore::Core::InternalThreadState *Thread, void *addr, size_t len, int prot, int pkey) -> uint64_t {
-      SYSCALL_STUB(pkey_mprotect);
-    });
-
-    REGISTER_SYSCALL_IMPL(pkey_alloc, [](FEXCore::Core::InternalThreadState *Thread, unsigned int flags, unsigned int access_rights) -> uint64_t {
-      SYSCALL_STUB(pkey_alloc);
-    });
-
-    REGISTER_SYSCALL_IMPL(pkey_free, [](FEXCore::Core::InternalThreadState *Thread, int pkey) -> uint64_t {
-      SYSCALL_STUB(pkey_free);
-    });
-
-    REGISTER_SYSCALL_IMPL(io_pgetevents, [](FEXCore::Core::InternalThreadState *Thread, aio_context_t ctx_id, long min_nr, long nr, struct io_event *events, struct timespec *timeout, const struct io_sigset  *usig) -> uint64_t {
-      SYSCALL_STUB(io_pgetevents);
-    });
-
     REGISTER_SYSCALL_IMPL(rseq, [](FEXCore::Core::InternalThreadState *Thread,  struct rseq  *rseq, uint32_t rseq_len, int flags, uint32_t sig) -> uint64_t {
       SYSCALL_STUB(rseq);
     });

External/FEXCore/Source/Interface/HLE/Syscalls/Thread.cpp

@@ -6,6 +6,7 @@
 #include <FEXCore/Core/CodeLoader.h>
 #include <FEXCore/Core/X86Enums.h>
 
+#include <grp.h>
 #include <limits.h>
 #include <linux/futex.h>
 #include <stdint.h>
@@ -185,7 +186,7 @@ namespace FEXCore::HLE {
       }
 
       if (!(flags & CLONE_THREAD)) {
-        
+
         if (flags & CLONE_VFORK) {
           flags &= ~CLONE_VFORK;
           flags &= ~CLONE_VM;
@@ -252,7 +253,7 @@ namespace FEXCore::HLE {
     // currently does not propagate argv[0] correctly
     REGISTER_SYSCALL_IMPL(execve, [](FEXCore::Core::InternalThreadState *Thread, const char *pathname, char *const argv[], char *const envp[]) -> uint64_t {
       std::vector<const char*> Args;
-      
+
       Thread->CTX->GetCodeLoader()->GetExecveArguments(&Args);
 
       Args.push_back("--");
@@ -269,7 +270,7 @@ namespace FEXCore::HLE {
       Args.push_back(nullptr);
 
       uint64_t Result = execve("/proc/self/exe", const_cast<char *const *>(&Args[0]), envp);
-      
+
       SYSCALL_ERRNO();
     });
 
@@ -367,6 +368,16 @@ namespace FEXCore::HLE {
       SYSCALL_ERRNO();
     });
 
+    REGISTER_SYSCALL_IMPL(getgroups, [](FEXCore::Core::InternalThreadState *Thread, int size, gid_t list[]) -> uint64_t {
+      uint64_t Result = ::getgroups(size, list);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(setgroups, [](FEXCore::Core::InternalThreadState *Thread, size_t size, const gid_t *list) -> uint64_t {
+      uint64_t Result = ::setgroups(size, list);
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL(setresuid, [](FEXCore::Core::InternalThreadState *Thread, uid_t ruid, uid_t euid, uid_t suid) -> uint64_t {
       uint64_t Result = ::setresuid(ruid, euid, suid);
       SYSCALL_ERRNO();
@@ -476,7 +487,7 @@ namespace FEXCore::HLE {
       SYSCALL_STUB(setpgid);
     });*/
     REGISTER_SYSCALL_FORWARD_ERRNO(setpgid);
-   
+
     /*REGISTER_SYSCALL_IMPL(getpgid, [](FEXCore::Core::InternalThreadState *Thread, pid_t pid) -> uint64_t {
       SYSCALL_STUB(getpgid);
     });*/
@@ -496,5 +507,20 @@ namespace FEXCore::HLE {
       SYSCALL_STUB(getsid);
     });*/
     REGISTER_SYSCALL_FORWARD_ERRNO(getsid);
+
+    REGISTER_SYSCALL_IMPL(waitid, [](FEXCore::Core::InternalThreadState *Thread, idtype_t idtype, id_t id, siginfo_t *infop, int options) -> uint64_t {
+      uint64_t Result = ::waitid(idtype, id, infop, options);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(unshare, [](FEXCore::Core::InternalThreadState *Thread, int flags) -> uint64_t {
+      uint64_t Result = ::unshare(flags);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(setns, [](FEXCore::Core::InternalThreadState *Thread, int fd, int nstype) -> uint64_t {
+      uint64_t Result = ::setns(fd, nstype);
+      SYSCALL_ERRNO();
+    });
   }
 }

External/FEXCore/Source/Interface/HLE/Syscalls/Time.cpp

@@ -5,6 +5,10 @@
 #include <stdint.h>
 #include <time.h>
 #include <sys/time.h>
+#include <sys/times.h>
+#include <sys/timex.h>
+#include <unistd.h>
+#include <utime.h>
 
 namespace FEXCore::Core {
 struct InternalThreadState;
@@ -12,6 +16,11 @@ struct InternalThreadState;
 
 namespace FEXCore::HLE {
   void RegisterTime() {
+    REGISTER_SYSCALL_IMPL(pause, [](FEXCore::Core::InternalThreadState *Thread) -> uint64_t {
+      uint64_t Result = ::pause();
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL(nanosleep, [](FEXCore::Core::InternalThreadState *Thread, const struct timespec *req, struct timespec *rem) -> uint64_t {
       uint64_t Result = ::nanosleep(req, rem);
       SYSCALL_ERRNO();
@@ -37,9 +46,44 @@ namespace FEXCore::HLE {
       SYSCALL_ERRNO();
     });
 
+    REGISTER_SYSCALL_IMPL(times, [](FEXCore::Core::InternalThreadState *Thread, struct tms *buf) -> uint64_t {
+      uint64_t Result = ::times(buf);
+      SYSCALL_ERRNO();
+    });
+
     REGISTER_SYSCALL_IMPL(clock_nanosleep, [](FEXCore::Core::InternalThreadState *Thread, clockid_t clockid, int flags, const struct timespec *request, struct timespec *remain) -> uint64_t {
       uint64_t Result = ::clock_nanosleep(clockid, flags, request, remain);
       SYSCALL_ERRNO();
     });
+
+    REGISTER_SYSCALL_IMPL(utime, [](FEXCore::Core::InternalThreadState *Thread, char* filename, const struct utimbuf* times) -> uint64_t {
+      uint64_t Result = ::utime(filename, times);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(adjtimex, [](FEXCore::Core::InternalThreadState *Thread, struct timex *buf) -> uint64_t {
+      uint64_t Result = ::adjtimex(buf);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(settimeofday, [](FEXCore::Core::InternalThreadState *Thread, const struct timeval *tv, const struct timezone *tz) -> uint64_t {
+      uint64_t Result = ::settimeofday(tv, tz);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(clock_settime, [](FEXCore::Core::InternalThreadState *Thread, clockid_t clockid, const struct timespec *tp) -> uint64_t {
+      uint64_t Result = ::clock_settime(clockid, tp);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(utimes, [](FEXCore::Core::InternalThreadState *Thread, const char *filename, const struct timeval times[2]) -> uint64_t {
+      uint64_t Result = ::utimes(filename, times);
+      SYSCALL_ERRNO();
+    });
+
+    REGISTER_SYSCALL_IMPL(clock_adjtime, [](FEXCore::Core::InternalThreadState *Thread, clockid_t clk_id, struct timex *buf) -> uint64_t {
+      uint64_t Result = ::clock_adjtime(clk_id, buf);
+      SYSCALL_ERRNO();
+    });
   }
 }

External/FEXCore/Source/Interface/HLE/x64/Syscalls.cpp

@@ -12,7 +12,9 @@ namespace FEXCore::HLE {
     void RegisterInfo();
     void RegisterIO();
     void RegisterIoctl();
+    void RegisterKey();
     void RegisterMemory();
+    void RegisterMsg();
     void RegisterNuma();
     void RegisterSched();
     void RegisterSemaphore();
@@ -134,7 +136,9 @@ namespace FEXCore::HLE::x64 {
     RegisterInfo();
     RegisterIO();
     RegisterIoctl();
+    RegisterKey();
     RegisterMemory();
+    RegisterMsg();
     RegisterSched();
     RegisterSemaphore();
     RegisterSHM();

unittests/POSIX/Known_Failures

@@ -2,10 +2,6 @@ conformance-interfaces-clock-1-1.test
 conformance-interfaces-clock_getcpuclockid-2-1.test
 conformance-interfaces-clock_nanosleep-11-1.test
 conformance-interfaces-clock_nanosleep-13-1.test
-conformance-interfaces-clock_settime-17-1.test
-conformance-interfaces-clock_settime-17-2.test
-conformance-interfaces-clock_settime-20-1.test
-conformance-interfaces-clock_settime-6-1.test
 conformance-interfaces-mlockall-8-1.test
 conformance-interfaces-munmap-2-1.test
 conformance-interfaces-nanosleep-10000-1.test