Add openat2 support

CMakeLists.txt

@@ -1134,6 +1134,7 @@ set(BASIC_TESTS
   numa
   x86/old_fork
   orphan_process
+  openat2
   packet_mmap_disable
   x86/patch_syscall_restart
   pause

src/AutoRemoteSyscalls.cc

@@ -849,7 +849,7 @@ void AutoRemoteSyscalls::check_syscall_result(long ret, int syscallno, bool allo
     string extra_msg;
     if (is_open_syscall(syscallno, arch())) {
       extra_msg = " opening " + t->read_c_str(t->regs().arg1());
-    } else if (is_openat_syscall(syscallno, arch())) {
+    } else if (is_openat_syscall(syscallno, arch()) || is_openat2_syscall(syscallno, arch())) {
       extra_msg = " opening " + t->read_c_str(t->regs().arg2());
     } else if (is_mremap_syscall(syscallno, arch()) ||
                is_mmap_syscall(syscallno, arch())) {

src/preload/syscallbuf.c

@@ -2522,6 +2522,40 @@ static long sys_openat(struct syscall_info* call) {
   return check_file_open_ok(call, ret, state);
 }
 
+#if defined(SYS_openat2)
+static long sys_openat2(struct syscall_info* call) {
+  if (force_traced_syscall_for_chaos_mode()) {
+    /* Opening a FIFO could unblock a higher priority task */
+    return traced_raw_syscall(call);
+  }
+
+  const int syscallno = SYS_openat2;
+  int dirfd = call->args[0];
+  const char* pathname = (const char*)call->args[1];
+  struct open_how *how = (struct open_how *)call->args[2];
+  size_t how_size = call->args[3];
+
+  void* ptr;
+  long ret;
+
+  assert(syscallno == call->no);
+
+  if (!supported_open(pathname, how->flags)) {
+    return traced_raw_syscall(call);
+  }
+
+  ptr = prep_syscall();
+  if (!start_commit_buffered_syscall(syscallno, ptr, MAY_BLOCK)) {
+    return traced_raw_syscall(call);
+  }
+
+  ret = untraced_syscall4(syscallno, dirfd, pathname, how, how_size);
+  struct check_open_state state = capture_check_open_state();
+  ret = commit_raw_syscall(syscallno, ptr, ret);
+  return check_file_open_ok(call, ret, state);
+}
+#endif
+
 #if defined(SYS_poll) || defined(SYS_ppoll)
 /**
  * Make this function external so desched_ticks.py can set a breakpoint on it.
@@ -4080,6 +4114,9 @@ case SYS_epoll_wait:
 #endif
 case SYS_epoll_pwait:
     return sys_epoll_wait(call);
+#if defined(SYS_openat2)
+    CASE(openat2);
+#endif
 #if defined(SYS_epoll_pwait2)
     CASE(epoll_pwait2);
 #endif

src/record_syscall.cc

@@ -4003,6 +4003,7 @@ static Switchable rec_prepare_syscall_arch(RecordTask* t,
     case Arch::msync:
     case Arch::open:
     case Arch::openat:
+    case Arch::openat2:
     case Arch::semop:
     case Arch::semtimedop_time64:
     case Arch::semtimedop:
@@ -6599,18 +6600,32 @@ static void rec_process_syscall_arch(RecordTask* t,
     }
 
     case Arch::open:
-    case Arch::openat: {
+    case Arch::openat:
+    case Arch::openat2: {
       Registers r = t->regs();
       if (r.syscall_failed()) {
-        uintptr_t path = syscallno == Arch::openat ? r.arg2() : r.orig_arg1();
+        uintptr_t path = syscallno == Arch::open ? r.orig_arg1() : r.arg2();
         string pathname = t->read_c_str(remote_ptr<char>(path));
         if (is_gcrypt_deny_file(pathname.c_str())) {
           fake_gcrypt_file(t, &r);
           t->set_regs(r);
         }
       } else {
         int fd = r.syscall_result_signed();
-        int flags = syscallno == Arch::openat ? r.arg3() : r.arg2();
+
+        int flags;
+        switch (syscallno) {
+        case Arch::open:
+          flags = r.arg2();
+          break;
+        case Arch::openat:
+          flags = r.arg3();
+          break;
+        case Arch::openat2:
+          flags = t->read_mem(remote_ptr<int64_t>(r.arg3()));
+          break;
+        }
+
         string pathname = handle_opened_file(t, fd, flags);
         bool gcrypt = is_gcrypt_deny_file(pathname.c_str());
         if (gcrypt || is_blacklisted_filename(pathname.c_str())) {

src/replay_syscall.cc

@@ -1330,6 +1330,9 @@ static void rep_process_syscall_arch(ReplayTask* t, ReplayTraceStep* step,
     case Arch::openat:
       handle_opened_files(t, t->regs().arg3());
       break;
+    case Arch::openat2:
+      handle_opened_files(t, t->read_mem(remote_ptr<int64_t>(t->regs().arg3())));
+      break;
     case Arch::open:
       handle_opened_files(t, t->regs().arg2());
       break;

src/syscalls.py

@@ -1726,7 +1726,7 @@ def __init__(self, **kwargs):
 fspick = UnsupportedSyscall(x86=433, x64=433, generic=433)
 pidfd_open = EmulatedSyscall(x86=434, x64=434, generic=434)
 clone3 = IrregularEmulatedSyscall(x86=435, x64=435, generic=435)
-openat2 = UnsupportedSyscall(x86=437, x64=437, generic=437)
+openat2 = IrregularEmulatedSyscall(x86=437, x64=437, generic=437)
 pidfd_getfd = EmulatedSyscall(x86=438, x64=438, generic=438)
 process_madvise = UnsupportedSyscall(x86=440, x64=440, generic=440)
 epoll_pwait2 = IrregularEmulatedSyscall(x86=441, x64=441, generic=441)

src/test/openat2.c

@@ -0,0 +1,48 @@
+/* -*- Mode: C; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */
+
+#include "util.h"
+
+#include <fcntl.h>          /* Definition of O_* and S_* constants */
+#include <linux/openat2.h>  /* Definition of RESOLVE_* constants */
+#include <sys/syscall.h>    /* Definition of SYS_* constants */
+#include <unistd.h>
+#include <errno.h>
+
+#define TEST_DIR "test_dir"
+#define FILENAME "foo"
+#define REL_FILENAME "../" TEST_DIR "/" FILENAME
+
+int main(void) {
+  mkdir(TEST_DIR, 0700);
+  int dirfd = open(TEST_DIR, O_DIRECTORY, 0755);
+  test_assert(dirfd > 0);
+
+  int filefd = openat(dirfd, FILENAME, O_CREAT | O_RDWR, 0600);
+  test_assert(filefd > 0);
+  test_assert(close(filefd) == 0);
+
+  struct open_how how = {0};
+  how.flags = O_CREAT | O_RDONLY;
+  how.mode = 0600;
+
+  how.resolve = RESOLVE_BENEATH;
+  filefd = syscall(SYS_openat2, dirfd, REL_FILENAME, &how, sizeof(how));
+  test_assert(filefd == -1);
+
+  // openat2 was introduced by Linux 5.6
+  // if the syscall isn't supported, return immediatly
+  if (errno == ENOSYS) {
+    atomic_puts("EXIT-SUCCESS");
+    return 0;
+  }
+
+  test_assert(errno == EXDEV);
+
+  how.resolve = 0;
+  filefd = syscall(SYS_openat2, dirfd, REL_FILENAME, &how, sizeof(how));
+  test_assert(filefd > 0);
+  test_assert(close(filefd) == 0);
+
+  atomic_puts("EXIT-SUCCESS");
+  return 0;
+}