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/files/scoped_file.h"
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "sandbox/linux/seccomp-bpf-helpers/sigsys_handlers.h"
+#include "sandbox/linux/seccomp-bpf/bpf_tests.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+int GetPageSize() {

[Mark Seaborn, 2014/04/15 23:03:14]

Just use the standard getpagesize() from unistd.h?

[hamaji, 2014/04/16 02:10:48]

I created this because the man page of getpagesize said POSIX deprecated
getpagesize(), but done. This file is only for linux anyway.

+  return sysconf(_SC_PAGESIZE);
+}
+
+void DoPipe(base::ScopedFD* fds) {
+  int tmp_fds[2];
+  BPF_ASSERT_EQ(0, pipe(tmp_fds));
+  fds[0].reset(tmp_fds[0]);
+  fds[1].reset(tmp_fds[1]);
+}
+
+void DoSocketpair(base::ScopedFD* fds) {
+  int tmp_fds[2];
+  BPF_ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, tmp_fds));
+  fds[0].reset(tmp_fds[0]);
+  fds[1].reset(tmp_fds[1]);
+}
+
+TEST(NaClNonSfiSandboxTest, BPFIsSupported) {
+  bool seccomp_bpf_supported = false;
+#if !defined(THREAD_SANITIZER)

[Mark Seaborn, 2014/04/15 23:03:14]

Can you add a comment saying why this is disabled under TSan?  Is this because
SupportsSeccompSandbox() forks a subprocess to check, and TSan doesn't like
that?

[jln (very slow on Chromium), 2014/04/16 01:36:11]

It's because TSAN got smarter at detecting fork() in a recent roll.
So, on fork(), TSAN creates a thread in the child. Supports() does fork and then
tries to engaged seccomp-bpf in the child, which it can't do because there is a
thread in there.

You can point to crbug.com/356588 as a comment.

[hamaji, 2014/04/16 02:18:00]

Thanks. Added a comment.

+  seccomp_bpf_supported = (

[jln (very slow on Chromium), 2014/04/16 01:39:38]

Do you mind also adding ASSERT_TRUE(ThreadHelpers::IsSingleThreaded(-1)); ?

[hamaji, 2014/04/16 02:18:00]

I'm happy to add this, but I guess this will fail on linux_tsan as well? Please
see the cover comment of my previous reply.

+      sandbox::SandboxBPF::SupportsSeccompSandbox(-1) ==
+      sandbox::SandboxBPF::STATUS_AVAILABLE);
+#endif
+
+  if (!seccomp_bpf_supported) {
+    LOG(ERROR) << "Seccomp BPF is not supported, these tests "
+               << "will pass without running";
+  }
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, invalid_sysno,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(999);
+}
+
+void* SetZeroInThread(void* test_val_ptr) {
+  *reinterpret_cast<int*>(test_val_ptr) = 0;

[Mark Seaborn, 2014/04/15 23:03:14]

Nit: use a non-zero value to make it more obvious where you check for this, e.g.
123

[jln (very slow on Chromium), 2014/04/16 01:36:11]

You might be the first person to not suggest 42 :)

[hamaji, 2014/04/16 02:10:48]

Done.

[hamaji, 2014/04/16 02:18:00]

Hehe, 42 has been already used as its initial value :)

+  return NULL;
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, clone_by_pthread_create,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  // clone call for thread creation is allowed.
+  pthread_t th;
+  int test_val = 42;
+  BPF_ASSERT_EQ(0, pthread_create(&th, NULL, &SetZeroInThread, &test_val));
+  BPF_ASSERT_EQ(0, pthread_join(th, NULL));
+  BPF_ASSERT_EQ(0, test_val);

[Mark Seaborn, 2014/04/15 23:03:14]

...then 123 here.

[hamaji, 2014/04/16 02:10:48]

Done.

+}
+
+int DoClone() {

[Mark Seaborn, 2014/04/15 23:03:14]

How about calling this DoFork()?

You're using clone() as fork() below, but that's not obvious, so can you comment
that?

(I started writing a comment saying this isn't safe to use clone() this way in
C.  But of course fork() is fine.)

[hamaji, 2014/04/16 02:10:48]

Done.

+  const int pid = syscall(__NR_clone,
+                          CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD,
+                          NULL);
+  if (pid == 0)
+    _exit(0);
+  return pid;
+}
+
+// The sanity check for DoClone without the sandbox.
+TEST(NaClNonSfiSandboxTest, DoClone) {
+  const int pid = DoClone();
+  ASSERT_LT(0, pid);
+  int status;
+  ASSERT_EQ(pid, HANDLE_EINTR(waitpid(pid, &status, 0)));
+  ASSERT_TRUE(WIFEXITED(status));
+  ASSERT_EQ(0, WEXITSTATUS(status));
+}
+
+// Then, try this in the sandbox.
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, clone,
+               DEATH_MESSAGE(sandbox::GetCloneErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  DoClone();
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, prctl_SET_NAME,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  errno = 0;
+  BPF_ASSERT_EQ(-1, syscall(__NR_prctl, PR_SET_NAME, "foo"));
+  BPF_ASSERT_EQ(EPERM, errno);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, prctl_SET_DUMPABLE,
+               DEATH_MESSAGE(sandbox::GetPrctlErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_prctl, PR_SET_DUMPABLE, 1UL);
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, socketcall_allowed,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  base::ScopedFD 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;
+  DoSocketpair(fds);
+  BPF_ASSERT_EQ(static_cast<int>(payload.size()),
+                HANDLE_EINTR(sendmsg(fds[1].get(), &msg, 0)));
+  BPF_ASSERT_EQ(static_cast<int>(payload.size()),
+                HANDLE_EINTR(recvmsg(fds[0].get(), &msg, 0)));
+  BPF_ASSERT_EQ(0, shutdown(fds[0].get(), SHUT_RDWR));
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, accept,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  accept(0, NULL, NULL);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, bind,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  bind(0, NULL, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, connect,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  connect(0, NULL, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getpeername,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  getpeername(0, NULL, NULL);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getsockname,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  getsockname(0, NULL, NULL);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getsockopt,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  getsockopt(0, 0, 0, NULL, NULL);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, listen,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  listen(0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, recv,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  recv(0, NULL, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, recvfrom,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  recvfrom(0, NULL, 0, 0, NULL, NULL);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, send,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  send(0, NULL, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sendto,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  sendto(0, NULL, 0, 0, NULL, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setsockopt,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  setsockopt(0, 0, 0, NULL, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, socket,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  socket(0, 0, 0);
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, socketpair,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  int fds[2];
+  socketpair(AF_INET, SOCK_STREAM, 0, fds);
+}
+#endif
+
+BPF_TEST(NaClNonSfiSandboxTest, fcntl_SETFD_allowed,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  base::ScopedFD fds[2];
+  DoSocketpair(fds);
+  BPF_ASSERT_EQ(0, fcntl(fds[0].get(), F_SETFD, FD_CLOEXEC));
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fcntl_SETFD,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  base::ScopedFD fds[2];
+  DoSocketpair(fds);
+  fcntl(fds[0].get(), F_SETFD, 99);
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, fcntl_GETFL_SETFL_allowed,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  base::ScopedFD fds[2];
+  DoPipe(fds);
+  const int fd = fds[0].get();
+  BPF_ASSERT_EQ(0, fcntl(fd, F_GETFL));
+  BPF_ASSERT_EQ(0, fcntl(fd, F_SETFL, O_RDWR | O_NONBLOCK));
+  BPF_ASSERT_EQ(O_NONBLOCK, fcntl(fd, F_GETFL));
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fcntl_GETFL_SETFL,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  base::ScopedFD fds[2];
+  DoSocketpair(fds);
+  fcntl(fds[0].get(), F_SETFL, O_APPEND);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fcntl_DUPFD,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  fcntl(0, F_DUPFD);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fcntl_DUPFD_CLOEXEC,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  fcntl(0, F_DUPFD_CLOEXEC);
+}
+
+void* DoAllowedAnonymousMmap() {
+  return mmap(NULL, GetPageSize(), PROT_READ | PROT_WRITE,
+              MAP_ANONYMOUS | MAP_SHARED, -1, 0);
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, mmap_allowed,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  void* ptr = DoAllowedAnonymousMmap();
+  BPF_ASSERT_NE(MAP_FAILED, ptr);
+  BPF_ASSERT_EQ(0, munmap(ptr, GetPageSize()));
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mmap_unallowed_flag,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  mmap(NULL, GetPageSize(), PROT_READ | PROT_WRITE,
+       MAP_ANONYMOUS | MAP_POPULATE, -1, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mmap_unallowed_prot,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  mmap(NULL, GetPageSize(), PROT_READ | PROT_GROWSDOWN,
+       MAP_ANONYMOUS, -1, 0);
+}
+
+// TODO(hamaji): Disallow RWX mmap.
+#if 0
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mmap_rwx,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  mmap(NULL, GetPageSize(), PROT_READ | PROT_WRITE | PROT_EXEC,
+       MAP_ANONYMOUS, -1, 0);
+}
+#endif
+
+BPF_TEST(NaClNonSfiSandboxTest, mprotect_allowed,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  void* ptr = DoAllowedAnonymousMmap();
+  BPF_ASSERT_NE(MAP_FAILED, ptr);
+  BPF_ASSERT_EQ(0, mprotect(ptr, GetPageSize(), PROT_READ));
+  BPF_ASSERT_EQ(0, munmap(ptr, GetPageSize()));
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mprotect_unallowed_prot,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  // We have tested DoAllowedAnonymousMmap is allowed in
+  // mmap_allowed, so we can make sure the following mprotect call
+  // kills the process.
+  void* ptr = DoAllowedAnonymousMmap();
+  BPF_ASSERT_NE(MAP_FAILED, ptr);
+  mprotect(ptr, GetPageSize(), PROT_READ | PROT_GROWSDOWN);
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, brk,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  char* next_brk = static_cast<char*>(sbrk(0)) + GetPageSize();
+  // The kernel interface must return zero for brk.
+  BPF_ASSERT_EQ(0, syscall(__NR_brk, next_brk));
+  // The libc wrapper translates it to ENOMEM.
+  errno = 0;
+  BPF_ASSERT_EQ(-1, brk(next_brk));
+  BPF_ASSERT_EQ(ENOMEM, errno);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_TEST(NaClNonSfiSandboxTest, getegid32_EPERM,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  errno = 0;
+  BPF_ASSERT_EQ(-1, syscall(__NR_getegid32));
+  BPF_ASSERT_EQ(EPERM, errno);
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, geteuid32_EPERM,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  errno = 0;
+  BPF_ASSERT_EQ(-1, syscall(__NR_geteuid32));
+  BPF_ASSERT_EQ(EPERM, errno);
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, getgid32_EPERM,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  errno = 0;
+  BPF_ASSERT_EQ(-1, syscall(__NR_getgid32));
+  BPF_ASSERT_EQ(EPERM, errno);
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, getuid32_EPERM,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  errno = 0;
+  BPF_ASSERT_EQ(-1, syscall(__NR_getuid32));
+  BPF_ASSERT_EQ(EPERM, errno);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getegid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getegid);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, geteuid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_geteuid);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getgid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getgid);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getuid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getuid);
+}
+#endif
+
+#if defined(__x86_64__)
+BPF_TEST(NaClNonSfiSandboxTest, getegid_EPERM,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  errno = 0;
+  BPF_ASSERT_EQ(-1, syscall(__NR_getegid));
+  BPF_ASSERT_EQ(EPERM, errno);
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, geteuid_EPERM,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  errno = 0;
+  BPF_ASSERT_EQ(-1, syscall(__NR_geteuid));
+  BPF_ASSERT_EQ(EPERM, errno);
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, getgid_EPERM,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  errno = 0;
+  BPF_ASSERT_EQ(-1, syscall(__NR_getgid));
+  BPF_ASSERT_EQ(EPERM, errno);
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, getuid_EPERM,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  errno = 0;
+  BPF_ASSERT_EQ(-1, syscall(__NR_getuid));
+  BPF_ASSERT_EQ(EPERM, errno);
+}
+#endif
+
+BPF_TEST(NaClNonSfiSandboxTest, madvise_EPERM,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  errno = 0;
+  BPF_ASSERT_EQ(-1, syscall(__NR_madvise));
+  BPF_ASSERT_EQ(EPERM, errno);
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, open_EPERM,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  errno = 0;
+  BPF_ASSERT_EQ(-1, syscall(__NR_open));
+  BPF_ASSERT_EQ(EPERM, errno);
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, ptrace_EPERM,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  errno = 0;
+  BPF_ASSERT_EQ(-1, syscall(__NR_ptrace));
+  BPF_ASSERT_EQ(EPERM, errno);
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, set_robust_list_EPERM,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  errno = 0;
+  BPF_ASSERT_EQ(-1, syscall(__NR_set_robust_list));
+  BPF_ASSERT_EQ(EPERM, errno);
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_TEST(NaClNonSfiSandboxTest, time_EPERM,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  errno = 0;
+  BPF_ASSERT_EQ(-1, syscall(__NR_time));
+  BPF_ASSERT_EQ(EPERM, errno);
+}
+#endif
+
+// The rest of syscalls should just raise SIGSYS regardless of
+// arguments. We always pass five zeros not to pass uninitialized
+// values to syscalls.
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, _newselect_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR__newselect, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, _sysctl_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR__sysctl, 0, 0, 0, 0, 0);
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, accept_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_accept, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, accept4_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_accept4, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, access_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_access, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, acct_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_acct, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, add_key_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_add_key, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, adjtimex_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_adjtimex, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, afs_syscall_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_afs_syscall, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, alarm_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_alarm, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, arch_prctl_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_arch_prctl, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, arm_fadvise64_64_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_arm_fadvise64_64, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, bdflush_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_bdflush, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, bind_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_bind, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, break_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_break, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, capget_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_capget, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, capset_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_capset, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, chdir_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_chdir, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, chmod_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_chmod, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, chown_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_chown, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, chown32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_chown32, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, chroot_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_chroot, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, clock_adjtime_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_clock_adjtime, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, clock_nanosleep_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_clock_nanosleep, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, clock_settime_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_clock_settime, 0, 0, 0, 0, 0);
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, connect_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_connect, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, creat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_creat, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, create_module_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_create_module, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, delete_module_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_delete_module, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, dup3_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_dup3, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, epoll_create1_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_epoll_create1, 0, 0, 0, 0, 0);
+}
+
+#if defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, epoll_ctl_old_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_epoll_ctl_old, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, epoll_pwait_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_epoll_pwait, 0, 0, 0, 0, 0);
+}
+
+#if defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, epoll_wait_old_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_epoll_wait_old, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, eventfd_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_eventfd, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, eventfd2_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_eventfd2, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, execve_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_execve, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, faccessat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_faccessat, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fadvise64_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fadvise64, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fadvise64_64_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fadvise64_64, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fallocate_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fallocate, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fanotify_init_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fanotify_init, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fanotify_mark_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fanotify_mark, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fchdir_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fchdir, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fchmod_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fchmod, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fchmodat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fchmodat, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fchown_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fchown, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fchown32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fchown32, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fchownat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fchownat, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fcntl_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fcntl, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fdatasync_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fdatasync, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fgetxattr_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fgetxattr, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, flistxattr_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_flistxattr, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, flock_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_flock, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fork_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fork, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fremovexattr_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fremovexattr, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fsetxattr_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fsetxattr, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fstat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fstat, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fstatat64_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fstatat64, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fstatfs_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fstatfs, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fstatfs64_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fstatfs64, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fsync_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_fsync, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ftime_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_ftime, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ftruncate_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_ftruncate, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ftruncate64_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_ftruncate64, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, futimesat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_futimesat, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, get_kernel_syms_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_get_kernel_syms, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, get_mempolicy_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_get_mempolicy, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, get_robust_list_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_get_robust_list, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, get_thread_area_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_get_thread_area, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getcpu_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getcpu, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getcwd_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getcwd, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getdents_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getdents, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getdents64_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getdents64, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getgroups_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getgroups, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getgroups32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getgroups32, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getitimer_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getitimer, 0, 0, 0, 0, 0);
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getpeername_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getpeername, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getpgid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getpgid, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getpgrp_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getpgrp, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getpid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getpid, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getpmsg_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getpmsg, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getppid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getppid, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getpriority_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getpriority, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getresgid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getresgid, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getresgid32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getresgid32, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getresuid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getresuid, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getresuid32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getresuid32, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getrlimit_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getrlimit, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getrusage_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getrusage, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getsid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getsid, 0, 0, 0, 0, 0);
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getsockname_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getsockname, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getsockopt_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getsockopt, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getxattr_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getxattr, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, gtty_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_gtty, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, idle_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_idle, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, init_module_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_init_module, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, inotify_add_watch_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_inotify_add_watch, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, inotify_init_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_inotify_init, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, inotify_init1_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_inotify_init1, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, inotify_rm_watch_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_inotify_rm_watch, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, io_cancel_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_io_cancel, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, io_destroy_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_io_destroy, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, io_getevents_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_io_getevents, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, io_setup_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_io_setup, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, io_submit_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_io_submit, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ioctl_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_ioctl, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ioperm_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_ioperm, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, iopl_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_iopl, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ioprio_get_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_ioprio_get, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ioprio_set_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_ioprio_set, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ipc_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_ipc, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, kexec_load_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_kexec_load, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, keyctl_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_keyctl, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, kill_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_kill, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, lchown_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_lchown, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, lchown32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_lchown32, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, lgetxattr_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_lgetxattr, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, link_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_link, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, linkat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_linkat, 0, 0, 0, 0, 0);
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, listen_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_listen, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, listxattr_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_listxattr, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, llistxattr_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_llistxattr, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, lock_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_lock, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, lookup_dcookie_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_lookup_dcookie, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, lremovexattr_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_lremovexattr, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, lseek_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_lseek, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, lsetxattr_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_lsetxattr, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, lstat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_lstat, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, lstat64_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_lstat64, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mbind_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mbind, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, migrate_pages_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_migrate_pages, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mincore_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mincore, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mkdir_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mkdir, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mkdirat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mkdirat, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mknod_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mknod, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mknodat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mknodat, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mlock_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mlock, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mlockall_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mlockall, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mmap_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mmap, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, modify_ldt_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_modify_ldt, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mount_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mount, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, move_pages_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_move_pages, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mpx_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mpx, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mq_getsetattr_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mq_getsetattr, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mq_notify_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mq_notify, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mq_open_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mq_open, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mq_timedreceive_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mq_timedreceive, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mq_timedsend_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mq_timedsend, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mq_unlink_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mq_unlink, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mremap_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_mremap, 0, 0, 0, 0, 0);
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, msgctl_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_msgctl, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, msgget_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_msgget, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, msgrcv_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_msgrcv, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, msgsnd_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_msgsnd, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, msync_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_msync, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, munlock_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_munlock, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, munlockall_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_munlockall, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, name_to_handle_at_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_name_to_handle_at, 0, 0, 0, 0, 0);
+}
+
+#if defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, newfstatat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_newfstatat, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, nfsservctl_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_nfsservctl, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, nice_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_nice, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, oldfstat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_oldfstat, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, oldlstat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_oldlstat, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, oldolduname_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_oldolduname, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, oldstat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_oldstat, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, olduname_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_olduname, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, open_by_handle_at_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_open_by_handle_at, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, openat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_openat, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, pause_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_pause, 0, 0, 0, 0, 0);
+}
+
+#if defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, pciconfig_iobase_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_pciconfig_iobase, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, pciconfig_read_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_pciconfig_read, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, pciconfig_write_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_pciconfig_write, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, perf_event_open_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_perf_event_open, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, personality_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_personality, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, pipe2_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_pipe2, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, pivot_root_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_pivot_root, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, poll_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_poll, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ppoll_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_ppoll, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, preadv_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_preadv, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, prlimit64_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_prlimit64, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, process_vm_readv_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_process_vm_readv, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, process_vm_writev_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_process_vm_writev, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, prof_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_prof, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, profil_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_profil, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, pselect6_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_pselect6, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, putpmsg_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_putpmsg, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, pwritev_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_pwritev, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, query_module_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_query_module, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, quotactl_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_quotactl, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, readahead_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_readahead, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, readdir_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_readdir, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, readlink_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_readlink, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, readlinkat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_readlinkat, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, readv_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_readv, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, reboot_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_reboot, 0, 0, 0, 0, 0);
+}
+
+#if defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, recv_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_recv, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, recvfrom_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_recvfrom, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, recvmmsg_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_recvmmsg, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, remap_file_pages_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_remap_file_pages, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, removexattr_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_removexattr, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, rename_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_rename, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, renameat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_renameat, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, request_key_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_request_key, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, rmdir_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_rmdir, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_sigaction_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_rt_sigaction, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_sigpending_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_rt_sigpending, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_sigprocmask_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_rt_sigprocmask, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_sigqueueinfo_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_rt_sigqueueinfo, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_sigreturn_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_rt_sigreturn, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_sigsuspend_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_rt_sigsuspend, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_sigtimedwait_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_rt_sigtimedwait, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_tgsigqueueinfo_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_rt_tgsigqueueinfo, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_get_priority_max_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sched_get_priority_max, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_get_priority_min_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sched_get_priority_min, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_getaffinity_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sched_getaffinity, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_getparam_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sched_getparam, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_getscheduler_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sched_getscheduler, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_rr_get_interval_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sched_rr_get_interval, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_setaffinity_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sched_setaffinity, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_setparam_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sched_setparam, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_setscheduler_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sched_setscheduler, 0, 0, 0, 0, 0);
+}
+
+#if defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, security_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_security, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, select_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_select, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, semctl_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_semctl, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, semget_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_semget, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, semop_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_semop, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, semtimedop_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_semtimedop, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, send_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_send, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sendfile_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sendfile, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sendfile64_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sendfile64, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sendmmsg_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sendmmsg, 0, 0, 0, 0, 0);
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sendto_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sendto, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, set_mempolicy_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_set_mempolicy, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, set_thread_area_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_set_thread_area, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, set_tid_address_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_set_tid_address, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setdomainname_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setdomainname, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setfsgid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setfsgid, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setfsgid32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setfsgid32, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setfsuid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setfsuid, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setfsuid32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setfsuid32, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setgid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setgid, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setgid32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setgid32, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setgroups_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setgroups, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setgroups32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setgroups32, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sethostname_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sethostname, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setitimer_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setitimer, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setns_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setns, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setpgid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setpgid, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setpriority_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setpriority, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setregid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setregid, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setregid32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setregid32, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setresgid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setresgid, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setresgid32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setresgid32, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setresuid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setresuid, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setresuid32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setresuid32, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setreuid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setreuid, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setreuid32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setreuid32, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setrlimit_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setrlimit, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setsid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setsid, 0, 0, 0, 0, 0);
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setsockopt_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setsockopt, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, settimeofday_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_settimeofday, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setuid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setuid, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setuid32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setuid32, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setxattr_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_setxattr, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sgetmask_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sgetmask, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, shmat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_shmat, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, shmctl_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_shmctl, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, shmdt_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_shmdt, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, shmget_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_shmget, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sigaction_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sigaction, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, signal_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_signal, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, signalfd_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_signalfd, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, signalfd4_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_signalfd4, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sigpending_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sigpending, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sigprocmask_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sigprocmask, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sigreturn_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sigreturn, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sigsuspend_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sigsuspend, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, socket_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_socket, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, splice_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_splice, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ssetmask_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_ssetmask, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, stat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_stat, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, stat64_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_stat64, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, statfs_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_statfs, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, statfs64_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_statfs64, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, stime_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_stime, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, stty_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_stty, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, swapoff_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_swapoff, 0, 0, 0, 0, 0);

[Mark Seaborn, 2014/04/15 23:03:14]

Crikey, this file is huge.

Does it really make sense to be copy-and-pasting all of this stuff?

Is there any reason to believe our whitelist doesn't actually function as a
whitelist?

Could we reduce the duplication here, e.g. by iterating through syscall numbers,
to check __NR_swapoff in 1 line instead of 6 lines?  We could do that
programmatically (with a loop that fork()s), or with a macro for defining tests.

One worry I'd have is that it's too hard to see which are the interesting tests
among all the copy-and-pasted tests.  At a minimum, we could put the
copy-and-pasted tests in a different file from the real tests.

[jln (very slow on Chromium), 2014/04/16 01:36:11]

I think it's useful to really test for all of this, in case there is a compiler
bug, or a bug in the policy.
I agree, it's unfortunate. I think we should list these system calls in a vector
and then iterate over this.

It's non trivial though, since we'll need to duplicate the BPF_DEATH_TEST logic.
How about doing this in a follow-up bug?

[hamaji, 2014/04/16 02:10:48]

I'm not sure if they are actually useful. I imagined they could be useful to
prevent a very weird bug in SandboxBPF or something.

I agree this file is too big and they are not interesting. I defined a few
macros to compress them and moved them to another file. Only whitelisted
syscalls exist in this file now.

+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, swapon_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_swapon, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, symlink_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_symlink, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, symlinkat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_symlinkat, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sync_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sync, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sync_file_range_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sync_file_range, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sync_file_range2_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sync_file_range2, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, syncfs_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_syncfs, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sysfs_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sysfs, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sysinfo_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_sysinfo, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, syslog_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_syslog, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, tee_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_tee, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, tgkill_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_tgkill, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, timer_create_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_timer_create, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, timer_delete_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_timer_delete, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, timer_getoverrun_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_timer_getoverrun, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, timer_gettime_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_timer_gettime, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, timer_settime_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_timer_settime, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, timerfd_create_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_timerfd_create, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, timerfd_gettime_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_timerfd_gettime, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, timerfd_settime_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_timerfd_settime, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, tkill_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_tkill, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, truncate_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_truncate, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, truncate64_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_truncate64, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, tuxcall_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_tuxcall, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ugetrlimit_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_ugetrlimit, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ulimit_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_ulimit, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, umask_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_umask, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, umount_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_umount, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, umount2_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_umount2, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, uname_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_uname, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, unlink_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_unlink, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, unlinkat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_unlinkat, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, unshare_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_unshare, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, uselib_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_uselib, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ustat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_ustat, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, utime_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_utime, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, utimensat_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_utimensat, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, utimes_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_utimes, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, vfork_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_vfork, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, vhangup_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_vhangup, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, vm86_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_vm86, 0, 0, 0, 0, 0);
+}
+#endif
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, vm86old_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_vm86old, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, vmsplice_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_vmsplice, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, vserver_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_vserver, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, wait4_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_wait4, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, waitid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_waitid, 0, 0, 0, 0, 0);
+}
+
+#if defined(__i386__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, waitpid_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_waitpid, 0, 0, 0, 0, 0);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, writev_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_writev, 0, 0, 0, 0, 0);
+}
+
+// ARM specific syscalls.
+#if defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ARM_breakpoint_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__ARM_NR_breakpoint, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ARM_usr26_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__ARM_NR_usr26, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ARM_usr32_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__ARM_NR_usr32, 0, 0, 0, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, ARM_set_tls_SIGSYS,
+               DEATH_MESSAGE(sandbox::GetErrorMessageContentForTests()),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__ARM_NR_set_tls, 0, 0, 0, 0, 0);
+}
+#endif
+
+}  // namespace