Add seccomp sandbox for non-SFI NaCl

components/nacl/loader/nonsfi/nonsfi_sandbox_unittest.cc

+// Copyright (c) 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/nacl/loader/nonsfi/nonsfi_sandbox.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <sched.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/prctl.h>
+#include <sys/ptrace.h>
+#include <sys/socket.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+static const char kSeccompFailureMsg[] = "seccomp-bpf failure";
+
+#define ASSERT_SIGSYS_MSG(expr, msg)                                    \

[jln (very slow on Chromium), 2014/04/08 00:51:10]

This doesn't look too bad, but in case you need it:

- Look at //sandbox/linux/seccomp-bpf/sandbox_bpf_unittest.cc to see some unit
tests and our helpers.

I think it's fine for components/ unittests to use the unittests helpers in
sandbox/.

- //sandbox/linux/services/scoped_process.h can be very handy.

[hamaji, 2014/04/09 21:09:09]

Ah, the test utilities are nice. I should have guessed there should be this kind
of test infra for seccomp. Done.

+  ASSERT_DEATH((nacl::nonsfi::InitializeBPFSandbox(), (expr)), msg)
+#define ASSERT_SIGSYS(expr) ASSERT_SIGSYS_MSG(expr, kSeccompFailureMsg)
+// We need to use ASSERT_EXIT even for non-crashing test because we
+// cannot reset the sandbox state of a process once it has been
+// enabled.
+#define ASSERT_ERRNO(expr, expected_errno)                              \
+  ASSERT_EXIT((nacl::nonsfi::InitializeBPFSandbox(),                    \
+               errno = 0, (expr), exit(errno)),                         \
+              ::testing::ExitedWithCode(expected_errno), "")
+#define ASSERT_EPERM(expr) ASSERT_ERRNO(expr, EPERM)
+#define ASSERT_ALLOWED(expr) ASSERT_ERRNO(expr, 0)
+
+class NaClNonSfiSandboxTest : public testing::Test {
+ public:
+  NaClNonSfiSandboxTest()
+    : page_size_(sysconf(_SC_PAGESIZE)) {
+  }
+
+  virtual void SetUp() OVERRIDE {
+    ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+  }
+
+ protected:
+  int page_size_;
+};
+
+TEST_F(NaClNonSfiSandboxTest, invalid_sysno) {
+  ASSERT_SIGSYS(syscall(999));
+}
+
+TEST_F(NaClNonSfiSandboxTest, ptrace_EPERM) {
+  ASSERT_EPERM(syscall(__NR_ptrace));
+}
+
+TEST_F(NaClNonSfiSandboxTest, set_robust_list_EPERM) {
+  ASSERT_EPERM(syscall(__NR_set_robust_list));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, getegid32_EPERM) {
+  ASSERT_EPERM(syscall(__NR_getegid32));
+}
+
+TEST_F(NaClNonSfiSandboxTest, geteuid32_EPERM) {
+  ASSERT_EPERM(syscall(__NR_geteuid32));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getgid32_EPERM) {
+  ASSERT_EPERM(syscall(__NR_getgid32));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getuid32_EPERM) {
+  ASSERT_EPERM(syscall(__NR_getuid32));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getegid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getegid));
+}
+
+TEST_F(NaClNonSfiSandboxTest, geteuid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_geteuid));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getgid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getgid));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getuid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getuid));
+}
+#endif
+
+#if defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, getegid_EPERM) {
+  ASSERT_EPERM(syscall(__NR_getegid));
+}
+
+TEST_F(NaClNonSfiSandboxTest, geteuid_EPERM) {
+  ASSERT_EPERM(syscall(__NR_geteuid));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getgid_EPERM) {
+  ASSERT_EPERM(syscall(__NR_getgid));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getuid_EPERM) {
+  ASSERT_EPERM(syscall(__NR_getuid));
+}
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, time_EPERM) {
+  ASSERT_EPERM(syscall(__NR_time));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, open_EPERM) {
+  ASSERT_EPERM(syscall(__NR_open));
+}
+
+TEST_F(NaClNonSfiSandboxTest, brk_0) {
+  char* next_brk = static_cast<char*>(sbrk(0)) + page_size_;
+  // The kernel interface must return zero for brk.
+  ASSERT_EXIT((nacl::nonsfi::InitializeBPFSandbox(),
+               exit(syscall(__NR_brk, next_brk) == 0)),
+               ::testing::ExitedWithCode(1), "");
+  // The libc wrapper translates it to ENOMEM.
+  ASSERT_ERRNO(brk(next_brk) != -1 && (exit(-1), 1), ENOMEM);
+}
+
+TEST_F(NaClNonSfiSandboxTest, madvise_EPERM) {
+  ASSERT_EPERM(syscall(__NR_madvise));
+}
+
+static void* SetZeroInThread(void* test_val_ptr) {
+  *reinterpret_cast<int*>(test_val_ptr) = 0;
+  return NULL;
+}
+
+static void CreateThread() {
+  pthread_t th;
+  int test_val = 42;
+  PCHECK(pthread_create(&th, NULL, &SetZeroInThread, &test_val) == 0);
+  PCHECK(pthread_join(th, NULL) == 0);
+  if (test_val != 0)
+    errno = -1;
+}
+
+static int DoClone() {
+  int pid = syscall(__NR_clone,
+                    CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, NULL);
+  if (pid == 0)
+    _Exit(0);
+  return pid;
+}
+
+TEST_F(NaClNonSfiSandboxTest, clone) {
+  ASSERT_ALLOWED(CreateThread());
+
+  // The sanity check for DoClone without the sandbox.
+  int pid = DoClone();
+  ASSERT_LT(0, pid);
+  int status;
+  ASSERT_EQ(pid, waitpid(pid, &status, 0));
+  ASSERT_EQ(1, WIFEXITED(status));
+  ASSERT_EQ(0, WEXITSTATUS(status));
+  // Then, try this in the sandbox.
+  ASSERT_SIGSYS_MSG(DoClone(), "");

[hamaji, 2014/04/07 21:17:59]

Julien: We should be able to use "clone\\(\\) failure" if sigsys_handlers.cc
does not have !defined(NDEBUG) around RAW_LOG. Why isn't it consistent
consistent with CrashSIGSYS_Handler, which always output a message to stderr? Is
it OK to remove !defined(NDEBUG) from sigsys_handlers.cc in a separate change?

[jln (very slow on Chromium), 2014/04/08 00:51:10]

Yes!

+}
+
+TEST_F(NaClNonSfiSandboxTest, prctl) {
+  ASSERT_EPERM(syscall(__NR_prctl, PR_SET_NAME, "foo"));
+  ASSERT_SIGSYS_MSG(syscall(__NR_prctl, PR_SET_DUMPABLE, 1UL), "");

[hamaji, 2014/04/07 21:17:59]

ditto.

+}
+
+TEST_F(NaClNonSfiSandboxTest, socketcall) {
+  int fds[2];
+  struct msghdr msg = {};
+  struct iovec iov;
+  std::string payload("foo");
+  iov.iov_base = &payload[0];
+  iov.iov_len = payload.size();
+  msg.msg_iov = &iov;
+  msg.msg_iovlen = 1;
+  ASSERT_ALLOWED((socketpair(AF_UNIX, SOCK_STREAM, 0, fds),
+                  sendmsg(fds[1], &msg, 0),
+                  recvmsg(fds[0], &msg, 0),
+                  close(fds[0]),
+                  close(fds[1])));
+
+  ASSERT_SIGSYS(accept(0, NULL, NULL));
+  ASSERT_SIGSYS(bind(0, NULL, 0));
+  ASSERT_SIGSYS(connect(0, NULL, 0));
+  ASSERT_SIGSYS(getpeername(0, NULL, NULL));
+  ASSERT_SIGSYS(getsockname(0, NULL, NULL));
+  ASSERT_SIGSYS(getsockopt(0, 0, 0, NULL, NULL));
+  ASSERT_SIGSYS(listen(0, 0));
+  ASSERT_SIGSYS(recv(0, NULL, 0, 0));
+  ASSERT_SIGSYS(recvfrom(0, NULL, 0, 0, NULL, NULL));
+  ASSERT_SIGSYS(send(0, NULL, 0, 0));
+  ASSERT_SIGSYS(sendto(0, NULL, 0, 0, NULL, 0));
+  ASSERT_SIGSYS(setsockopt(0, 0, 0, NULL, 0));
+  ASSERT_SIGSYS(shutdown(0, 0));
+  ASSERT_SIGSYS(socket(0, 0, 0));
+#if defined(__x86_64__) || defined(__arm__)
+  ASSERT_SIGSYS(socketpair(AF_INET, SOCK_STREAM, 0, fds));
+#endif
+}
+
+TEST_F(NaClNonSfiSandboxTest, fcntl) {
+  int fds[2];
+  ASSERT_EQ(0, pipe(fds));
+  int fd = fds[0];
+  ASSERT_ALLOWED(fcntl(fd, F_SETFD, FD_CLOEXEC));
+  ASSERT_SIGSYS(fcntl(fd, F_SETFD, 99));
+  ASSERT_ALLOWED(fcntl(fd, F_GETFL));
+  ASSERT_ALLOWED(fcntl(fd, F_SETFL, O_RDWR | O_NONBLOCK));
+  ASSERT_SIGSYS(fcntl(fd, F_SETFL, O_APPEND));
+  ASSERT_SIGSYS(fcntl(fd, F_DUPFD));
+  ASSERT_SIGSYS(fcntl(fd, F_DUPFD_CLOEXEC));
+  close(fds[0]);
+  close(fds[1]);
+}
+
+TEST_F(NaClNonSfiSandboxTest, mmap) {
+  ASSERT_ALLOWED(munmap(mmap(NULL, page_size_, PROT_READ | PROT_WRITE,
+                             MAP_ANONYMOUS | MAP_SHARED,
+                             -1, 0), page_size_));
+  ASSERT_SIGSYS(mmap(NULL, page_size_, PROT_READ | PROT_WRITE,
+                     MAP_ANONYMOUS | MAP_POPULATE, -1, 0));
+  ASSERT_SIGSYS(mmap(NULL, page_size_, PROT_READ | PROT_WRITE,
+                     MAP_ANONYMOUS | MAP_POPULATE, -1, 0));
+  ASSERT_SIGSYS(mmap(NULL, page_size_, PROT_READ | PROT_GROWSDOWN,
+                     MAP_ANONYMOUS | MAP_POPULATE, -1, 0));
+}
+
+TEST_F(NaClNonSfiSandboxTest, mprotect) {
+  void* ptr = mmap(NULL, page_size_, PROT_READ | PROT_WRITE,
+                   MAP_ANONYMOUS | MAP_SHARED, -1, 0);
+  ASSERT_NE(MAP_FAILED, ptr);
+  ASSERT_ALLOWED(mprotect(ptr, page_size_, PROT_READ));
+  ASSERT_SIGSYS(mprotect(ptr, page_size_, PROT_READ | PROT_GROWSDOWN));
+  ASSERT_EQ(0, munmap(ptr, page_size_));
+}
+
+// The rest of syscalls should just raise SIGSYS regardless of arguments.
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, _newselect_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR__newselect));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, _sysctl_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR__sysctl));
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, accept_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_accept));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, accept4_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_accept4));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, access_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_access));
+}
+
+TEST_F(NaClNonSfiSandboxTest, acct_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_acct));
+}
+
+TEST_F(NaClNonSfiSandboxTest, add_key_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_add_key));
+}
+
+TEST_F(NaClNonSfiSandboxTest, adjtimex_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_adjtimex));
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, afs_syscall_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_afs_syscall));
+}
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, alarm_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_alarm));
+}
+#endif
+
+#if defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, arch_prctl_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_arch_prctl));
+}
+#endif
+
+#if defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, arm_fadvise64_64_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_arm_fadvise64_64));
+}
+#endif
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, bdflush_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_bdflush));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, bind_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_bind));
+}
+#endif
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, break_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_break));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, capget_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_capget));
+}
+
+TEST_F(NaClNonSfiSandboxTest, capset_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_capset));
+}
+
+TEST_F(NaClNonSfiSandboxTest, chdir_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_chdir));
+}
+
+TEST_F(NaClNonSfiSandboxTest, chmod_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_chmod));
+}
+
+TEST_F(NaClNonSfiSandboxTest, chown_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_chown));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, chown32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_chown32));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, chroot_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_chroot));
+}
+
+TEST_F(NaClNonSfiSandboxTest, clock_adjtime_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_clock_adjtime));
+}
+
+TEST_F(NaClNonSfiSandboxTest, clock_nanosleep_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_clock_nanosleep));
+}
+
+TEST_F(NaClNonSfiSandboxTest, clock_settime_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_clock_settime));
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, connect_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_connect));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, creat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_creat));
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, create_module_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_create_module));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, delete_module_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_delete_module));
+}
+
+TEST_F(NaClNonSfiSandboxTest, dup3_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_dup3));
+}
+
+TEST_F(NaClNonSfiSandboxTest, epoll_create1_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_epoll_create1));
+}
+
+#if defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, epoll_ctl_old_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_epoll_ctl_old));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, epoll_pwait_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_epoll_pwait));
+}
+
+#if defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, epoll_wait_old_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_epoll_wait_old));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, eventfd_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_eventfd));
+}
+
+TEST_F(NaClNonSfiSandboxTest, eventfd2_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_eventfd2));
+}
+
+TEST_F(NaClNonSfiSandboxTest, execve_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_execve));
+}
+
+TEST_F(NaClNonSfiSandboxTest, faccessat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_faccessat));
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, fadvise64_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fadvise64));
+}
+#endif
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, fadvise64_64_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fadvise64_64));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, fallocate_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fallocate));
+}
+
+TEST_F(NaClNonSfiSandboxTest, fanotify_init_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fanotify_init));
+}
+
+TEST_F(NaClNonSfiSandboxTest, fanotify_mark_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fanotify_mark));
+}
+
+TEST_F(NaClNonSfiSandboxTest, fchdir_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fchdir));
+}
+
+TEST_F(NaClNonSfiSandboxTest, fchmod_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fchmod));
+}
+
+TEST_F(NaClNonSfiSandboxTest, fchmodat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fchmodat));
+}
+
+TEST_F(NaClNonSfiSandboxTest, fchown_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fchown));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, fchown32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fchown32));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, fchownat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fchownat));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, fcntl_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fcntl));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, fdatasync_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fdatasync));
+}
+
+TEST_F(NaClNonSfiSandboxTest, fgetxattr_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fgetxattr));
+}
+
+TEST_F(NaClNonSfiSandboxTest, flistxattr_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_flistxattr));
+}
+
+TEST_F(NaClNonSfiSandboxTest, flock_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_flock));
+}
+
+TEST_F(NaClNonSfiSandboxTest, fork_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fork));
+}
+
+TEST_F(NaClNonSfiSandboxTest, fremovexattr_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fremovexattr));
+}
+
+TEST_F(NaClNonSfiSandboxTest, fsetxattr_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fsetxattr));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, fstat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fstat));
+}
+#endif
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, fstatat64_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fstatat64));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, fstatfs_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fstatfs));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, fstatfs64_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fstatfs64));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, fsync_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_fsync));
+}
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, ftime_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_ftime));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, ftruncate_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_ftruncate));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, ftruncate64_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_ftruncate64));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, futimesat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_futimesat));
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, get_kernel_syms_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_get_kernel_syms));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, get_mempolicy_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_get_mempolicy));
+}
+
+TEST_F(NaClNonSfiSandboxTest, get_robust_list_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_get_robust_list));
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, get_thread_area_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_get_thread_area));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, getcpu_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getcpu));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getcwd_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getcwd));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getdents_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getdents));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getdents64_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getdents64));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getgroups_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getgroups));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, getgroups32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getgroups32));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, getitimer_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getitimer));
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, getpeername_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getpeername));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, getpgid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getpgid));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getpgrp_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getpgrp));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getpid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getpid));
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, getpmsg_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getpmsg));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, getppid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getppid));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getpriority_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getpriority));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getresgid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getresgid));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, getresgid32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getresgid32));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, getresuid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getresuid));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, getresuid32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getresuid32));
+}
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, getrlimit_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getrlimit));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, getrusage_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getrusage));
+}
+
+TEST_F(NaClNonSfiSandboxTest, getsid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getsid));
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, getsockname_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getsockname));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, getsockopt_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getsockopt));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, getxattr_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_getxattr));
+}
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, gtty_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_gtty));
+}
+#endif
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, idle_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_idle));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, init_module_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_init_module));
+}
+
+TEST_F(NaClNonSfiSandboxTest, inotify_add_watch_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_inotify_add_watch));
+}
+
+TEST_F(NaClNonSfiSandboxTest, inotify_init_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_inotify_init));
+}
+
+TEST_F(NaClNonSfiSandboxTest, inotify_init1_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_inotify_init1));
+}
+
+TEST_F(NaClNonSfiSandboxTest, inotify_rm_watch_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_inotify_rm_watch));
+}
+
+TEST_F(NaClNonSfiSandboxTest, io_cancel_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_io_cancel));
+}
+
+TEST_F(NaClNonSfiSandboxTest, io_destroy_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_io_destroy));
+}
+
+TEST_F(NaClNonSfiSandboxTest, io_getevents_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_io_getevents));
+}
+
+TEST_F(NaClNonSfiSandboxTest, io_setup_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_io_setup));
+}
+
+TEST_F(NaClNonSfiSandboxTest, io_submit_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_io_submit));
+}
+
+TEST_F(NaClNonSfiSandboxTest, ioctl_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_ioctl));
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, ioperm_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_ioperm));
+}
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, iopl_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_iopl));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, ioprio_get_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_ioprio_get));
+}
+
+TEST_F(NaClNonSfiSandboxTest, ioprio_set_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_ioprio_set));
+}
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, ipc_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_ipc));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, kexec_load_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_kexec_load));
+}
+
+TEST_F(NaClNonSfiSandboxTest, keyctl_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_keyctl));
+}
+
+TEST_F(NaClNonSfiSandboxTest, kill_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_kill));
+}
+
+TEST_F(NaClNonSfiSandboxTest, lchown_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_lchown));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, lchown32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_lchown32));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, lgetxattr_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_lgetxattr));
+}
+
+TEST_F(NaClNonSfiSandboxTest, link_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_link));
+}
+
+TEST_F(NaClNonSfiSandboxTest, linkat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_linkat));
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, listen_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_listen));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, listxattr_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_listxattr));
+}
+
+TEST_F(NaClNonSfiSandboxTest, llistxattr_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_llistxattr));
+}
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, lock_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_lock));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, lookup_dcookie_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_lookup_dcookie));
+}
+
+TEST_F(NaClNonSfiSandboxTest, lremovexattr_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_lremovexattr));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, lseek_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_lseek));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, lsetxattr_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_lsetxattr));
+}
+
+TEST_F(NaClNonSfiSandboxTest, lstat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_lstat));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, lstat64_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_lstat64));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, mbind_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mbind));
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, migrate_pages_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_migrate_pages));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, mincore_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mincore));
+}
+
+TEST_F(NaClNonSfiSandboxTest, mkdir_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mkdir));
+}
+
+TEST_F(NaClNonSfiSandboxTest, mkdirat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mkdirat));
+}
+
+TEST_F(NaClNonSfiSandboxTest, mknod_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mknod));
+}
+
+TEST_F(NaClNonSfiSandboxTest, mknodat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mknodat));
+}
+
+TEST_F(NaClNonSfiSandboxTest, mlock_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mlock));
+}
+
+TEST_F(NaClNonSfiSandboxTest, mlockall_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mlockall));
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, mmap_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mmap));
+}
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, modify_ldt_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_modify_ldt));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, mount_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mount));
+}
+
+TEST_F(NaClNonSfiSandboxTest, move_pages_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_move_pages));
+}
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, mpx_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mpx));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, mq_getsetattr_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mq_getsetattr));
+}
+
+TEST_F(NaClNonSfiSandboxTest, mq_notify_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mq_notify));
+}
+
+TEST_F(NaClNonSfiSandboxTest, mq_open_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mq_open));
+}
+
+TEST_F(NaClNonSfiSandboxTest, mq_timedreceive_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mq_timedreceive));
+}
+
+TEST_F(NaClNonSfiSandboxTest, mq_timedsend_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mq_timedsend));
+}
+
+TEST_F(NaClNonSfiSandboxTest, mq_unlink_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mq_unlink));
+}
+
+TEST_F(NaClNonSfiSandboxTest, mremap_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_mremap));
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, msgctl_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_msgctl));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, msgget_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_msgget));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, msgrcv_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_msgrcv));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, msgsnd_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_msgsnd));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, msync_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_msync));
+}
+
+TEST_F(NaClNonSfiSandboxTest, munlock_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_munlock));
+}
+
+TEST_F(NaClNonSfiSandboxTest, munlockall_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_munlockall));
+}
+
+TEST_F(NaClNonSfiSandboxTest, name_to_handle_at_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_name_to_handle_at));
+}
+
+#if defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, newfstatat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_newfstatat));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, nfsservctl_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_nfsservctl));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, nice_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_nice));
+}
+#endif
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, oldfstat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_oldfstat));
+}
+#endif
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, oldlstat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_oldlstat));
+}
+#endif
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, oldolduname_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_oldolduname));
+}
+#endif
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, oldstat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_oldstat));
+}
+#endif
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, olduname_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_olduname));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, open_by_handle_at_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_open_by_handle_at));
+}
+
+TEST_F(NaClNonSfiSandboxTest, openat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_openat));
+}
+
+TEST_F(NaClNonSfiSandboxTest, pause_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_pause));
+}
+
+#if defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, pciconfig_iobase_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_pciconfig_iobase));
+}
+#endif
+
+#if defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, pciconfig_read_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_pciconfig_read));
+}
+#endif
+
+#if defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, pciconfig_write_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_pciconfig_write));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, perf_event_open_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_perf_event_open));
+}
+
+TEST_F(NaClNonSfiSandboxTest, personality_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_personality));
+}
+
+TEST_F(NaClNonSfiSandboxTest, pipe2_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_pipe2));
+}
+
+TEST_F(NaClNonSfiSandboxTest, pivot_root_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_pivot_root));
+}
+
+TEST_F(NaClNonSfiSandboxTest, poll_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_poll));
+}
+
+TEST_F(NaClNonSfiSandboxTest, ppoll_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_ppoll));
+}
+
+TEST_F(NaClNonSfiSandboxTest, preadv_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_preadv));
+}
+
+TEST_F(NaClNonSfiSandboxTest, prlimit64_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_prlimit64));
+}
+
+TEST_F(NaClNonSfiSandboxTest, process_vm_readv_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_process_vm_readv));
+}
+
+TEST_F(NaClNonSfiSandboxTest, process_vm_writev_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_process_vm_writev));
+}
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, prof_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_prof));
+}
+#endif
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, profil_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_profil));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, pselect6_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_pselect6));
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, putpmsg_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_putpmsg));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, pwrite64_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_pwrite64));
+}
+
+TEST_F(NaClNonSfiSandboxTest, pwritev_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_pwritev));
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, query_module_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_query_module));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, quotactl_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_quotactl));
+}
+
+TEST_F(NaClNonSfiSandboxTest, readahead_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_readahead));
+}
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, readdir_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_readdir));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, readlink_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_readlink));
+}
+
+TEST_F(NaClNonSfiSandboxTest, readlinkat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_readlinkat));
+}
+
+TEST_F(NaClNonSfiSandboxTest, readv_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_readv));
+}
+
+TEST_F(NaClNonSfiSandboxTest, reboot_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_reboot));
+}
+
+#if defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, recv_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_recv));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, recvfrom_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_recvfrom));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, recvmmsg_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_recvmmsg));
+}
+
+TEST_F(NaClNonSfiSandboxTest, remap_file_pages_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_remap_file_pages));
+}
+
+TEST_F(NaClNonSfiSandboxTest, removexattr_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_removexattr));
+}
+
+TEST_F(NaClNonSfiSandboxTest, rename_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_rename));
+}
+
+TEST_F(NaClNonSfiSandboxTest, renameat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_renameat));
+}
+
+TEST_F(NaClNonSfiSandboxTest, request_key_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_request_key));
+}
+
+TEST_F(NaClNonSfiSandboxTest, rmdir_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_rmdir));
+}
+
+TEST_F(NaClNonSfiSandboxTest, rt_sigaction_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_rt_sigaction));
+}
+
+TEST_F(NaClNonSfiSandboxTest, rt_sigpending_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_rt_sigpending));
+}
+
+TEST_F(NaClNonSfiSandboxTest, rt_sigprocmask_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_rt_sigprocmask));
+}
+
+TEST_F(NaClNonSfiSandboxTest, rt_sigqueueinfo_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_rt_sigqueueinfo));
+}
+
+TEST_F(NaClNonSfiSandboxTest, rt_sigreturn_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_rt_sigreturn));
+}
+
+TEST_F(NaClNonSfiSandboxTest, rt_sigsuspend_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_rt_sigsuspend));
+}
+
+TEST_F(NaClNonSfiSandboxTest, rt_sigtimedwait_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_rt_sigtimedwait));
+}
+
+TEST_F(NaClNonSfiSandboxTest, rt_tgsigqueueinfo_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_rt_tgsigqueueinfo));
+}
+
+TEST_F(NaClNonSfiSandboxTest, sched_get_priority_max_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sched_get_priority_max));
+}
+
+TEST_F(NaClNonSfiSandboxTest, sched_get_priority_min_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sched_get_priority_min));
+}
+
+TEST_F(NaClNonSfiSandboxTest, sched_getaffinity_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sched_getaffinity));
+}
+
+TEST_F(NaClNonSfiSandboxTest, sched_getparam_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sched_getparam));
+}
+
+TEST_F(NaClNonSfiSandboxTest, sched_getscheduler_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sched_getscheduler));
+}
+
+TEST_F(NaClNonSfiSandboxTest, sched_rr_get_interval_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sched_rr_get_interval));
+}
+
+TEST_F(NaClNonSfiSandboxTest, sched_setaffinity_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sched_setaffinity));
+}
+
+TEST_F(NaClNonSfiSandboxTest, sched_setparam_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sched_setparam));
+}
+
+TEST_F(NaClNonSfiSandboxTest, sched_setscheduler_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sched_setscheduler));
+}
+
+#if defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, security_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_security));
+}
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, select_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_select));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, semctl_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_semctl));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, semget_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_semget));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, semop_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_semop));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, semtimedop_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_semtimedop));
+}
+#endif
+
+#if defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, send_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_send));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, sendfile_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sendfile));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, sendfile64_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sendfile64));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, sendmmsg_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sendmmsg));
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, sendto_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sendto));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, set_mempolicy_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_set_mempolicy));
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, set_thread_area_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_set_thread_area));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, set_tid_address_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_set_tid_address));
+}
+
+TEST_F(NaClNonSfiSandboxTest, setdomainname_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setdomainname));
+}
+
+TEST_F(NaClNonSfiSandboxTest, setfsgid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setfsgid));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, setfsgid32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setfsgid32));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, setfsuid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setfsuid));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, setfsuid32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setfsuid32));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, setgid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setgid));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, setgid32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setgid32));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, setgroups_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setgroups));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, setgroups32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setgroups32));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, sethostname_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sethostname));
+}
+
+TEST_F(NaClNonSfiSandboxTest, setitimer_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setitimer));
+}
+
+TEST_F(NaClNonSfiSandboxTest, setns_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setns));
+}
+
+TEST_F(NaClNonSfiSandboxTest, setpgid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setpgid));
+}
+
+TEST_F(NaClNonSfiSandboxTest, setpriority_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setpriority));
+}
+
+TEST_F(NaClNonSfiSandboxTest, setregid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setregid));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, setregid32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setregid32));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, setresgid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setresgid));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, setresgid32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setresgid32));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, setresuid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setresuid));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, setresuid32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setresuid32));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, setreuid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setreuid));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, setreuid32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setreuid32));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, setrlimit_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setrlimit));
+}
+
+TEST_F(NaClNonSfiSandboxTest, setsid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setsid));
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, setsockopt_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setsockopt));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, settimeofday_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_settimeofday));
+}
+
+TEST_F(NaClNonSfiSandboxTest, setuid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setuid));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, setuid32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setuid32));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, setxattr_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_setxattr));
+}
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, sgetmask_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sgetmask));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, shmat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_shmat));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, shmctl_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_shmctl));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, shmdt_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_shmdt));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, shmget_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_shmget));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, shutdown_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_shutdown));
+}
+#endif
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, sigaction_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sigaction));
+}
+#endif
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, signal_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_signal));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, signalfd_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_signalfd));
+}
+
+TEST_F(NaClNonSfiSandboxTest, signalfd4_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_signalfd4));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, sigpending_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sigpending));
+}
+#endif
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, sigprocmask_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sigprocmask));
+}
+#endif
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, sigreturn_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sigreturn));
+}
+#endif
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, sigsuspend_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sigsuspend));
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, socket_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_socket));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, splice_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_splice));
+}
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, ssetmask_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_ssetmask));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, stat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_stat));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, stat64_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_stat64));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, statfs_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_statfs));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, statfs64_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_statfs64));
+}
+#endif
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, stime_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_stime));
+}
+#endif
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, stty_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_stty));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, swapoff_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_swapoff));
+}
+
+TEST_F(NaClNonSfiSandboxTest, swapon_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_swapon));
+}
+
+TEST_F(NaClNonSfiSandboxTest, symlink_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_symlink));
+}
+
+TEST_F(NaClNonSfiSandboxTest, symlinkat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_symlinkat));
+}
+
+TEST_F(NaClNonSfiSandboxTest, sync_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sync));
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, sync_file_range_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sync_file_range));
+}
+#endif
+
+#if defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, sync_file_range2_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sync_file_range2));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, syncfs_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_syncfs));
+}
+
+TEST_F(NaClNonSfiSandboxTest, sysfs_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sysfs));
+}
+
+TEST_F(NaClNonSfiSandboxTest, sysinfo_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_sysinfo));
+}
+
+TEST_F(NaClNonSfiSandboxTest, syslog_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_syslog));
+}
+
+TEST_F(NaClNonSfiSandboxTest, tee_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_tee));
+}
+
+TEST_F(NaClNonSfiSandboxTest, tgkill_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_tgkill));
+}
+
+TEST_F(NaClNonSfiSandboxTest, timer_create_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_timer_create));
+}
+
+TEST_F(NaClNonSfiSandboxTest, timer_delete_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_timer_delete));
+}
+
+TEST_F(NaClNonSfiSandboxTest, timer_getoverrun_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_timer_getoverrun));
+}
+
+TEST_F(NaClNonSfiSandboxTest, timer_gettime_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_timer_gettime));
+}
+
+TEST_F(NaClNonSfiSandboxTest, timer_settime_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_timer_settime));
+}
+
+TEST_F(NaClNonSfiSandboxTest, timerfd_create_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_timerfd_create));
+}
+
+TEST_F(NaClNonSfiSandboxTest, timerfd_gettime_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_timerfd_gettime));
+}
+
+TEST_F(NaClNonSfiSandboxTest, timerfd_settime_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_timerfd_settime));
+}
+
+TEST_F(NaClNonSfiSandboxTest, tkill_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_tkill));
+}
+
+TEST_F(NaClNonSfiSandboxTest, truncate_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_truncate));
+}
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, truncate64_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_truncate64));
+}
+#endif
+
+#if defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, tuxcall_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_tuxcall));
+}
+#endif
+
+#if defined(__i386__) || defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, ugetrlimit_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_ugetrlimit));
+}
+#endif
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, ulimit_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_ulimit));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, umask_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_umask));
+}
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, umount_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_umount));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, umount2_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_umount2));
+}
+
+TEST_F(NaClNonSfiSandboxTest, uname_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_uname));
+}
+
+TEST_F(NaClNonSfiSandboxTest, unlink_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_unlink));
+}
+
+TEST_F(NaClNonSfiSandboxTest, unlinkat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_unlinkat));
+}
+
+TEST_F(NaClNonSfiSandboxTest, unshare_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_unshare));
+}
+
+TEST_F(NaClNonSfiSandboxTest, uselib_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_uselib));
+}
+
+TEST_F(NaClNonSfiSandboxTest, ustat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_ustat));
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+TEST_F(NaClNonSfiSandboxTest, utime_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_utime));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, utimensat_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_utimensat));
+}
+
+TEST_F(NaClNonSfiSandboxTest, utimes_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_utimes));
+}
+
+TEST_F(NaClNonSfiSandboxTest, vfork_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_vfork));
+}
+
+TEST_F(NaClNonSfiSandboxTest, vhangup_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_vhangup));
+}
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, vm86_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_vm86));
+}
+#endif
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, vm86old_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_vm86old));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, vmsplice_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_vmsplice));
+}
+
+TEST_F(NaClNonSfiSandboxTest, vserver_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_vserver));
+}
+
+TEST_F(NaClNonSfiSandboxTest, wait4_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_wait4));
+}
+
+TEST_F(NaClNonSfiSandboxTest, waitid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_waitid));
+}
+
+#if defined(__i386__)
+TEST_F(NaClNonSfiSandboxTest, waitpid_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_waitpid));
+}
+#endif
+
+TEST_F(NaClNonSfiSandboxTest, writev_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__NR_writev));
+}
+
+// ARM specific syscalls.
+#if defined(__arm__)
+TEST_F(NaClNonSfiSandboxTest, ARM_breakpoint_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__ARM_NR_breakpoint));
+}
+
+TEST_F(NaClNonSfiSandboxTest, ARM_usr26_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__ARM_NR_usr26));
+}
+
+TEST_F(NaClNonSfiSandboxTest, ARM_usr32_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__ARM_NR_usr32));
+}
+
+TEST_F(NaClNonSfiSandboxTest, ARM_set_tls_SIGSYS) {
+  ASSERT_SIGSYS(syscall(__ARM_NR_set_tls));
+}
+#endif