Non-SFI mode: Add syscalls which are needed for nacl_helper_nonsfi's sandbox.

src/nonsfi/linux/linux_sys_private.c

 /*
  * Copyright (c) 2014 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*
  * This file defines various POSIX-like functions directly using Linux
  * syscalls.  This is analogous to src/untrusted/nacl/sys_private.c, which
  * defines functions using NaCl syscalls directly.
@@ skipping 16 matching lines @@
 #include "native_client/src/nonsfi/linux/linux_syscall_defines.h"
 #include "native_client/src/nonsfi/linux/linux_syscall_structs.h"
 #include "native_client/src/nonsfi/linux/linux_syscall_wrappers.h"
 #include "native_client/src/nonsfi/linux/linux_syscalls.h"
 #include "native_client/src/public/linux_syscalls/poll.h"
 #include "native_client/src/public/linux_syscalls/sys/prctl.h"
 #include "native_client/src/public/linux_syscalls/sys/socket.h"
 #include "native_client/src/untrusted/nacl/tls.h"
 
 
+/* Used in openat() and fstatat(). */
+#define LINUX_AT_FDCWD (-100)
+
 /*
  * Note that Non-SFI NaCl uses a 4k page size, in contrast to SFI NaCl's
  * 64k page size.
  */
 static const int kPageSize = 0x1000;
 
 static uintptr_t errno_value_call(uintptr_t result) {
   if (linux_is_error_result(result)) {
     errno = -result;
     return -1;
@@ skipping 120 matching lines @@
 int read(int fd, void *buf, size_t count) {
   return errno_value_call(linux_syscall3(__NR_read, fd,
                                          (uintptr_t) buf, count));
 }
 
 int write(int fd, const void *buf, size_t count) {
   return errno_value_call(linux_syscall3(__NR_write, fd,
                                          (uintptr_t) buf, count));
 }
 
-int open(char const *pathname, int oflag, ...) {
+int open(const char *pathname, int oflag, ...) {
   mode_t cmode;
-  va_list ap;
 
-  if (oflag & O_CREAT) {
+  oflag = nacl_oflags_to_linux_oflags(oflag);
+  if (oflag == -1) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if (oflag & LINUX_O_CREAT) {
+    va_list ap;
     va_start(ap, oflag);
     cmode = va_arg(ap, mode_t);
     va_end(ap);
   } else {
     cmode = 0;
   }
 
   return errno_value_call(
       linux_syscall3(__NR_open, (uintptr_t) pathname, oflag, cmode));
 }
 
+int openat(int dirfd, const char *pathname, int oflag, ...) {
+  mode_t cmode;
+
+  if (dirfd == AT_FDCWD)
+    dirfd = LINUX_AT_FDCWD;
+
+  oflag = nacl_oflags_to_linux_oflags(oflag);
+  if (oflag == -1) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if (oflag & LINUX_O_CREAT) {
+    va_list ap;
+    va_start(ap, oflag);
+    cmode = va_arg(ap, mode_t);
+    va_end(ap);
+  } else {
+    cmode = 0;
+  }
+
+  return errno_value_call(
+      linux_syscall4(__NR_openat, dirfd, (uintptr_t) pathname, oflag, cmode));
+}
+
 int close(int fd) {
   return errno_value_call(linux_syscall1(__NR_close, fd));
 }
 
 ssize_t pread(int fd, void *buf, size_t count, off_t offset) {
   uint32_t offset_low = (uint32_t) offset;
   uint32_t offset_high = offset >> 32;
 #if defined(__i386__)
   return errno_value_call(
       linux_syscall5(__NR_pread64, fd, (uintptr_t) buf, count,
@@ skipping 75 matching lines @@
 int lstat(const char *file, struct stat *st) {
   struct linux_abi_stat64 linux_st;
   int rc = errno_value_call(
       linux_syscall2(__NR_lstat64, (uintptr_t) file, (uintptr_t) &linux_st));
   if (rc == -1)
     return -1;
   linux_stat_to_nacl_stat(&linux_st, st);
   return 0;
 }
 
+int fstatat(int dirfd, const char *file, struct stat *st, int flags) {
+  struct linux_abi_stat64 linux_st;
+  if (dirfd == AT_FDCWD)
+    dirfd = LINUX_AT_FDCWD;
+  int rc = errno_value_call(linux_syscall4(
+      __NR_fstatat64, dirfd, (uintptr_t) file, (uintptr_t) &linux_st, flags));
+  if (rc == -1)
+    return -1;
+  linux_stat_to_nacl_stat(&linux_st, st);
+  return 0;
+}
+
 int mkdir(const char *path, mode_t mode) {
   return errno_value_call(linux_syscall2(__NR_mkdir, (uintptr_t) path, mode));
 }
 
 int rmdir(const char *path) {
   return errno_value_call(linux_syscall1(__NR_rmdir, (uintptr_t) path));
 }
 
 int chdir(const char *path) {
   return errno_value_call(linux_syscall1(__NR_chdir, (uintptr_t) path));
@@ skipping 57 matching lines @@
       linux_syscall2(__NR_access, (uintptr_t) path, amode));
 }
 
 int readlink(const char *path, char *buf, int bufsize) {
   return errno_value_call(
       linux_syscall3(__NR_readlink, (uintptr_t) path,
                      (uintptr_t) buf, bufsize));
 }
 
 int fcntl(int fd, int cmd, ...) {
-  if (cmd == F_GETFL || cmd == F_GETFD) {
+  if (cmd == F_GETFD) {
     return errno_value_call(linux_syscall2(__NR_fcntl64, fd, cmd));
   }
-  if (cmd == F_SETFL || cmd == F_SETFD) {
+  if (cmd == F_GETFL) {
+    int rc = errno_value_call(linux_syscall2(__NR_fcntl64, fd, cmd));
+    if (rc == -1)
+      return -1;
+    return linux_oflags_to_nacl_oflags(rc);
+  }
+  if (cmd == F_SETFD) {
     va_list ap;
     va_start(ap, cmd);
     int32_t arg = va_arg(ap, int32_t);
     va_end(ap);
     return errno_value_call(linux_syscall3(__NR_fcntl64, fd, cmd, arg));
   }
+  if (cmd == F_SETFL) {
+    va_list ap;
+    va_start(ap, cmd);
+    int32_t arg = va_arg(ap, int32_t);
+    va_end(ap);
+    arg = nacl_oflags_to_linux_oflags(arg);
+    if (arg == -1) {
+      errno = EINVAL;
+      return -1;
+    }
+    return errno_value_call(linux_syscall3(__NR_fcntl64, fd, cmd, arg));
+  }
   /* We only support the fcntl commands above. */
   errno = EINVAL;
   return -1;
 }
 
 int getpid(void) {
   return errno_value_call(linux_syscall0(__NR_getpid));
 }
 
 int fork(void) {
@@ skipping 217 matching lines @@
 
 void *nacl_tls_get(void) {
   void *result;
 #if defined(__i386__)
   __asm__("mov %%gs:0, %0" : "=r"(result));
 #elif defined(__arm__)
   __asm__("mrc p15, 0, %0, c13, c0, 3" : "=r"(result));
 #endif
   return result;
 }