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 156 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;
+
+  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;
+  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) {

[Mark Seaborn, 2014/11/27 16:12:17]

What in sandbox/linux/ requires using F_GETFL?  Can you say in the commit
message?  This flags conversion adds a lot of complexity so I'd like to check
what it's needed for.

[hidehiko, 2014/11/28 16:58:15]

Used in some places at least in ipc_channel_posix.cc. E.g.;

https://code.google.com/p/chromium/codesearch#chromium/src/ipc/ipc_channel_po...
https://code.google.com/p/chromium/codesearch#chromium/src/ipc/ipc_channel_po...

[Mark Seaborn, 2014/12/08 22:09:02]

So this is needed for ipc/ rather than for the seccomp sandbox?

But we are already using ipc/ this way for the nacl_helper_nonsfi-based tests. 
How come those tests work?  Does enabling the sandbox cause this part of ipc/ to
fail?

Can you make this clearer in the commit message, please?

[hidehiko, 2014/12/09 08:38:48]

Why it is working now is because the flags used by IPC module have same value
with linux platform. I.e., IPC module does not use the flags whose value is
different between NaCl ABI and Linux.

Updated the commit message.

+    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 19 matching lines @@
 int isatty(int fd) {
   struct linux_termios term;
   return errno_value_call(
       linux_syscall3(__NR_ioctl, fd, LINUX_TCGETS, (uintptr_t) &term)) == 0;
 }
 
 int pipe(int pipefd[2]) {
   return errno_value_call(linux_syscall1(__NR_pipe, (uintptr_t) pipefd));
 }
 
+int pipe2(int pipefd[2], int flags) {

[Mark Seaborn, 2014/11/27 16:12:17]

Same here -- what uses pipe2()?  Is it something we really need for
nacl_helper_nonsfi?

[hidehiko, 2014/11/28 16:58:15]

Good catch. It was removed very recently, after this CL is set to review.
Removed.

+  flags = nacl_oflags_to_linux_oflags(flags);
+  if (flags == -1) {
+    errno = EINVAL;
+    return -1;
+  }
+  return errno_value_call(
+      linux_syscall2(__NR_pipe2, (uintptr_t) pipefd, flags));
+}
+
 int poll(struct pollfd *fds, nfds_t nfds, int timeout) {
   return errno_value_call(
       linux_syscall3(__NR_poll, (uintptr_t) fds, nfds, timeout));
 }
 
 int prctl(int option, uintptr_t arg2, uintptr_t arg3,
           uintptr_t arg4, uintptr_t arg5) {
   return errno_value_call(
       linux_syscall5(__NR_prctl, option, arg2, arg3, arg4, arg5));
 }
@@ skipping 178 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;
 }