Add seccomp sandbox for non-SFI NaCl

components/nacl/loader/nonsfi/nonsfi_sandbox_unittest.cc

Index: components/nacl/loader/nonsfi/nonsfi_sandbox_unittest.cc
diff --git a/components/nacl/loader/nonsfi/nonsfi_sandbox_unittest.cc b/components/nacl/loader/nonsfi/nonsfi_sandbox_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b60ebf86809ed2520f179da5018fc83e6bb876b0
--- /dev/null
+++ b/components/nacl/loader/nonsfi/nonsfi_sandbox_unittest.cc
@@ -0,0 +1,2704 @@
+// Copyright (c) 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/nacl/loader/nonsfi/nonsfi_sandbox.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <sched.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/prctl.h>
+#include <sys/ptrace.h>
+#include <sys/socket.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "sandbox/linux/seccomp-bpf/bpf_tests.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+static const char kSeccompFailureMsg[] = "seccomp-bpf failure";

[jln (very slow on Chromium), 2014/04/11 19:29:54]

This is a hidden dependency on the messages in sigsys_handlers.cc

Could we do better?

Maybe add a GetErrorMessageContentForTests() in sigsys_handlers.h

Then do something along the lines of

#define SECCOMP_MESSAGE_COMMON_CONTENT "seccomp-bpf failures" in
sigsys_handlers.cc and replace that string with SECCOMP_MESSAGE_COMMON_CONTENT
inside the existing strings.

[hamaji, 2014/04/15 15:09:25]

Done.

+
+static int GetPageSize() {
+  return sysconf(_SC_PAGESIZE);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, invalid_sysno,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(999);
+}
+
+static void* SetZeroInThread(void* test_val_ptr) {
+  *reinterpret_cast<int*>(test_val_ptr) = 0;
+  return NULL;
+}
+
+static int DoClone() {
+  int pid = syscall(__NR_clone,
+                    CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, NULL);
+  if (pid == 0)
+    _Exit(0);

[jln (very slow on Chromium), 2014/04/11 19:29:54]

Nit: _exit() is more common.

[hamaji, 2014/04/15 15:09:25]

Done.

+  return pid;
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, clone_by_pthread_create,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  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);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, clone,
+         DEATH_MESSAGE("clone() failure"),
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  // The sanity check for DoClone without the sandbox.

[jln (very slow on Chromium), 2014/04/11 19:29:54]

Why do you say this is not running in the sandbox?

[hamaji, 2014/04/15 15:09:25]

Sorry, this was not wrong when I didn't use BPF_DEATH_TEST. I didn't think a lot
when I changed all TEST to BPF_TEST or BPF_DEATH_TEST, so some tests were
invalid, as you mentioned. Thanks for the catch.

+  int pid = DoClone();
+  BPF_ASSERT_LT(0, pid);
+  int status;
+  BPF_ASSERT_EQ(pid, waitpid(pid, &status, 0));

[jln (very slow on Chromium), 2014/04/11 19:29:54]

HANDLE_EINTR()

[hamaji, 2014/04/15 15:09:25]

Done.

+  BPF_ASSERT_EQ(1, WIFEXITED(status));

[jln (very slow on Chromium), 2014/04/11 19:29:54]

I don't think you have a guarantee that this will be 1. I would just
BPF_ASSERT(WIFEXITED())

[hamaji, 2014/04/15 15:09:25]

Done.

+  BPF_ASSERT_EQ(0, WEXITSTATUS(status));
+  // Then, try this in the sandbox.
+  DoClone();

[jln (very slow on Chromium), 2014/04/11 19:29:54]

I don't understand what you're doing here. But the test is dangerously
constructed: how could you know if the first DoClone() causes SIGSYS or the
second?

[hamaji, 2014/04/15 15:09:25]

Now I splitted this BPF_DEATH_TEST into two tests. I did the same for some other
tests.

+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, prctl,
+               DEATH_MESSAGE("prctl() failure"),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  errno = 0;
+  BPF_ASSERT_EQ(-1, syscall(__NR_prctl, PR_SET_NAME, "foo"));
+  BPF_ASSERT_EQ(EPERM, errno);
+  syscall(__NR_prctl, PR_SET_DUMPABLE, 1UL);
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, socketcall_allowed,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  int fds[2];
+  struct msghdr msg = {};
+  struct iovec iov;
+  std::string payload("foo");
+  iov.iov_base = &payload[0];
+  iov.iov_len = payload.size();
+  msg.msg_iov = &iov;
+  msg.msg_iovlen = 1;
+  BPF_ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
+  BPF_ASSERT_EQ(static_cast<int>(payload.size()), sendmsg(fds[1], &msg, 0));

[hamaji, 2014/04/11 01:25:58]

I found this assertion was wrong but this test didn't catch this issue before I
changed ASSERT_EQ to BPF_ASSERT_EQ. Interesting...

[jln (very slow on Chromium), 2014/04/11 19:29:54]

Yeah, GTEST blows up silently when one uses fork(). That's why we has to create
our own BPF_ASSERT etc..

+  BPF_ASSERT_EQ(static_cast<int>(payload.size()), recvmsg(fds[0], &msg, 0));
+  BPF_ASSERT_EQ(0, close(fds[0]));
+  BPF_ASSERT_EQ(0, close(fds[1]));
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, accept,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  accept(0, NULL, NULL);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, bind,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  bind(0, NULL, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, connect,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  connect(0, NULL, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getpeername,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  getpeername(0, NULL, NULL);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getsockname,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  getsockname(0, NULL, NULL);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getsockopt,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  getsockopt(0, 0, 0, NULL, NULL);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, listen,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  listen(0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, recv,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  recv(0, NULL, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, recvfrom,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  recvfrom(0, NULL, 0, 0, NULL, NULL);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, send,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  send(0, NULL, 0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, sendto,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  sendto(0, NULL, 0, 0, NULL, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, setsockopt,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  setsockopt(0, 0, 0, NULL, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, shutdown,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  shutdown(0, 0);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, socket,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  socket(0, 0, 0);
+}
+
+#if defined(__x86_64__) || defined(__arm__)
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, socketpair,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  int fds[2];
+  socketpair(AF_INET, SOCK_STREAM, 0, fds);
+}
+#endif
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fcntl_SETFD,
+               DEATH_MESSAGE(kSeccompFailureMsg),

[jln (very slow on Chromium), 2014/04/11 20:19:47]

Same remark as above: you need to split this into two tests:

1. a normal test for the case that should be allowed.
2. a second test for the case that will SIGSYS.

[hamaji, 2014/04/15 15:09:25]

Done.

+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  int fds[2];
+  BPF_ASSERT_EQ(0, pipe(fds));
+  int fd = fds[0];
+  BPF_ASSERT_EQ(0, fcntl(fd, F_SETFD, FD_CLOEXEC));
+  fcntl(fd, F_SETFD, 99);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fcntl_GETFL_SETFL,
+               DEATH_MESSAGE(kSeccompFailureMsg),

[jln (very slow on Chromium), 2014/04/11 20:19:47]

Same remark: split

[hamaji, 2014/04/15 15:09:25]

Done.

+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  int fds[2];
+  BPF_ASSERT_EQ(0, pipe(fds));
+  int fd = fds[0];
+  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));
+  fcntl(fd, F_SETFL, O_APPEND);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fcntl_DUPFD,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  fcntl(0, F_DUPFD);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, fcntl_DUPFD_CLOEXEC,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  fcntl(0, F_DUPFD_CLOEXEC);
+}
+
+BPF_TEST(NaClNonSfiSandboxTest, mmap_allowed,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  void* ptr = mmap(NULL, GetPageSize(), PROT_READ | PROT_WRITE,
+                   MAP_ANONYMOUS | MAP_SHARED, -1, 0);
+  BPF_ASSERT_NE(MAP_FAILED, ptr);
+  BPF_ASSERT_EQ(0, munmap(ptr, GetPageSize()));
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, mmap_unallowed_flag,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               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(kSeccompFailureMsg),
+               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(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  mmap(NULL, GetPageSize(), PROT_READ | PROT_WRITE | PROT_EXEC,
+       MAP_ANONYMOUS, -1, 0);
+}
+#endif
+
+BPF_TEST(NaClNonSfiSandboxTest, mprotect,
+         nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  void* ptr = mmap(NULL, GetPageSize(), PROT_READ | PROT_WRITE,
+                   MAP_ANONYMOUS | MAP_SHARED, -1, 0);
+  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(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  void* ptr = mmap(NULL, GetPageSize(), PROT_READ | PROT_WRITE,
+                   MAP_ANONYMOUS | MAP_SHARED, -1, 0);
+  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(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getegid);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, geteuid_SIGSYS,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_geteuid);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getgid_SIGSYS,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
+  syscall(__NR_getgid);
+}
+
+BPF_DEATH_TEST(NaClNonSfiSandboxTest, getuid_SIGSYS,
+               DEATH_MESSAGE(kSeccompFailureMsg),
+               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.

[jln (very slow on Chromium), 2014/04/11 20:19:47]

I wonder if we shouldn't fix 5 arguments (to 0) regardless, just to prevent
flakiness (I think the syscall() wrapper might leave the unused arguments
uninitialized).

[hamaji, 2014/04/15 15:09:25]

Done. Isn't there a syscall which takes 6 arguments? I'm asking this because the
table in this man page has from arg1 to arg6.

http://man7.org/linux/man-pages/man2/syscall.2.html

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