Update from chromium https://crrev.com/301315

sandbox/linux/bpf_dsl/bpf_dsl_more_unittest.cc

 // Copyright (c) 2012 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 "sandbox/linux/bpf_dsl/bpf_dsl.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <sched.h>
@@ skipping 14 matching lines @@
 #include <linux/futex.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
+#include "sandbox/linux/bpf_dsl/policy.h"
 #include "sandbox/linux/seccomp-bpf/bpf_tests.h"
 #include "sandbox/linux/seccomp-bpf/die.h"
 #include "sandbox/linux/seccomp-bpf/errorcode.h"
 #include "sandbox/linux/seccomp-bpf/linux_seccomp.h"
 #include "sandbox/linux/seccomp-bpf/sandbox_bpf.h"
 #include "sandbox/linux/seccomp-bpf/syscall.h"
 #include "sandbox/linux/seccomp-bpf/trap.h"
 #include "sandbox/linux/services/broker_process.h"
 #include "sandbox/linux/services/linux_syscalls.h"
 #include "sandbox/linux/tests/scoped_temporary_file.h"
@@ skipping 56 matching lines @@
 // and it helps us accidentally forgetting any of the crucial steps in
 // setting up the sandbox. But it wouldn't hurt to have at least one test
 // that explicitly walks through all these steps.
 
 intptr_t IncreaseCounter(const struct arch_seccomp_data& args, void* aux) {
   BPF_ASSERT(aux);
   int* counter = static_cast<int*>(aux);
   return (*counter)++;
 }
 
-class VerboseAPITestingPolicy : public SandboxBPFDSLPolicy {
+class VerboseAPITestingPolicy : public Policy {
  public:
   explicit VerboseAPITestingPolicy(int* counter_ptr)
       : counter_ptr_(counter_ptr) {}
   virtual ~VerboseAPITestingPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override {
     DCHECK(SandboxBPF::IsValidSyscallNumber(sysno));
     if (sysno == __NR_uname) {
       return Trap(IncreaseCounter, counter_ptr_);
     }
@@ skipping 18 matching lines @@
     BPF_ASSERT_EQ(0, counter);
     BPF_ASSERT_EQ(0, syscall(__NR_uname, 0));
     BPF_ASSERT_EQ(1, counter);
     BPF_ASSERT_EQ(1, syscall(__NR_uname, 0));
     BPF_ASSERT_EQ(2, counter);
   }
 }
 
 // A simple blacklist test
 
-class BlacklistNanosleepPolicy : public SandboxBPFDSLPolicy {
+class BlacklistNanosleepPolicy : public Policy {
  public:
   BlacklistNanosleepPolicy() {}
   virtual ~BlacklistNanosleepPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override {
     DCHECK(SandboxBPF::IsValidSyscallNumber(sysno));
     switch (sysno) {
       case __NR_nanosleep:
         return Error(EACCES);
       default:
@@ skipping 11 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(BlacklistNanosleepPolicy);
 };
 
 BPF_TEST_C(SandboxBPF, ApplyBasicBlacklistPolicy, BlacklistNanosleepPolicy) {
   BlacklistNanosleepPolicy::AssertNanosleepFails();
 }
 
 // Now do a simple whitelist test
 
-class WhitelistGetpidPolicy : public SandboxBPFDSLPolicy {
+class WhitelistGetpidPolicy : public Policy {
  public:
   WhitelistGetpidPolicy() {}
   virtual ~WhitelistGetpidPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override {
     DCHECK(SandboxBPF::IsValidSyscallNumber(sysno));
     switch (sysno) {
       case __NR_getpid:
       case __NR_exit_group:
         return Allow();
@@ skipping 18 matching lines @@
 }
 
 // A simple blacklist policy, with a SIGSYS handler
 intptr_t EnomemHandler(const struct arch_seccomp_data& args, void* aux) {
   // We also check that the auxiliary data is correct
   SANDBOX_ASSERT(aux);
   *(static_cast<int*>(aux)) = kExpectedReturnValue;
   return -ENOMEM;
 }
 
-class BlacklistNanosleepTrapPolicy : public SandboxBPFDSLPolicy {
+class BlacklistNanosleepTrapPolicy : public Policy {
  public:
   explicit BlacklistNanosleepTrapPolicy(int* aux) : aux_(aux) {}
   virtual ~BlacklistNanosleepTrapPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override {
     DCHECK(SandboxBPF::IsValidSyscallNumber(sysno));
     switch (sysno) {
       case __NR_nanosleep:
         return Trap(EnomemHandler, aux_);
       default:
@@ skipping 21 matching lines @@
   const struct timespec ts = {0, 0};
   BPF_ASSERT(syscall(__NR_nanosleep, &ts, NULL) == -1);
   BPF_ASSERT(errno == ENOMEM);
 
   // We expect the signal handler to modify AuxData
   BPF_ASSERT(*BPF_AUX == kExpectedReturnValue);
 }
 
 // A simple test that verifies we can return arbitrary errno values.
 
-class ErrnoTestPolicy : public SandboxBPFDSLPolicy {
+class ErrnoTestPolicy : public Policy {
  public:
   ErrnoTestPolicy() {}
   virtual ~ErrnoTestPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ErrnoTestPolicy);
 };
 
@@ skipping 61 matching lines @@
 
   // Finally, test an errno in between the minimum and maximum.
   errno = 0;
   struct utsname uts_buf;
   BPF_ASSERT(uname(&uts_buf) == -1);
   BPF_ASSERT(errno == 42);
 }
 
 // Testing the stacking of two sandboxes
 
-class StackingPolicyPartOne : public SandboxBPFDSLPolicy {
+class StackingPolicyPartOne : public Policy {
  public:
   StackingPolicyPartOne() {}
   virtual ~StackingPolicyPartOne() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override {
     DCHECK(SandboxBPF::IsValidSyscallNumber(sysno));
     switch (sysno) {
       case __NR_getppid: {
         const Arg<int> arg(0);
         return If(arg == 0, Allow()).Else(Error(EPERM));
       }
       default:
         return Allow();
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StackingPolicyPartOne);
 };
 
-class StackingPolicyPartTwo : public SandboxBPFDSLPolicy {
+class StackingPolicyPartTwo : public Policy {
  public:
   StackingPolicyPartTwo() {}
   virtual ~StackingPolicyPartTwo() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override {
     DCHECK(SandboxBPF::IsValidSyscallNumber(sysno));
     switch (sysno) {
       case __NR_getppid: {
         const Arg<int> arg(0);
         return If(arg == 0, Error(EINVAL)).Else(Allow());
@@ skipping 37 matching lines @@
 // We try to make sure we exercise optimizations in the BPF compiler. We make
 // sure that the compiler can have an opportunity to coalesce syscalls with
 // contiguous numbers and we also make sure that disjoint sets can return the
 // same errno.
 int SysnoToRandomErrno(int sysno) {
   // Small contiguous sets of 3 system calls return an errno equal to the
   // index of that set + 1 (so that we never return a NUL errno).
   return ((sysno & ~3) >> 2) % 29 + 1;
 }
 
-class SyntheticPolicy : public SandboxBPFDSLPolicy {
+class SyntheticPolicy : public Policy {
  public:
   SyntheticPolicy() {}
   virtual ~SyntheticPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override {
     DCHECK(SandboxBPF::IsValidSyscallNumber(sysno));
     if (sysno == __NR_exit_group || sysno == __NR_write) {
       // exit_group() is special, we really need it to work.
       // write() is needed for BPF_ASSERT() to report a useful error message.
       return Allow();
@@ skipping 32 matching lines @@
 // MIN_PRIVATE_SYSCALL plus 1 (to avoid NUL errno).
 int ArmPrivateSysnoToErrno(int sysno) {
   if (sysno >= static_cast<int>(MIN_PRIVATE_SYSCALL) &&
       sysno <= static_cast<int>(MAX_PRIVATE_SYSCALL)) {
     return (sysno - MIN_PRIVATE_SYSCALL) + 1;
   } else {
     return ENOSYS;
   }
 }
 
-class ArmPrivatePolicy : public SandboxBPFDSLPolicy {
+class ArmPrivatePolicy : public Policy {
  public:
   ArmPrivatePolicy() {}
   virtual ~ArmPrivatePolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override {
     DCHECK(SandboxBPF::IsValidSyscallNumber(sysno));
     // Start from |__ARM_NR_set_tls + 1| so as not to mess with actual
     // ARM private system calls.
     if (sysno >= static_cast<int>(__ARM_NR_set_tls + 1) &&
         sysno <= static_cast<int>(MAX_PRIVATE_SYSCALL)) {
@@ skipping 23 matching lines @@
 
   // Verify that within the callback function all filtering is temporarily
   // disabled.
   BPF_ASSERT(syscall(__NR_getpid) > 1);
 
   // Verify that we can now call the underlying system call without causing
   // infinite recursion.
   return SandboxBPF::ForwardSyscall(args);
 }
 
-class GreyListedPolicy : public SandboxBPFDSLPolicy {
+class GreyListedPolicy : public Policy {
  public:
   explicit GreyListedPolicy(int* aux) : aux_(aux) {
     // Set the global environment for unsafe traps once.
     EnableUnsafeTraps();
   }
   virtual ~GreyListedPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override {
     DCHECK(SandboxBPF::IsValidSyscallNumber(sysno));
     // Some system calls must always be allowed, if our policy wants to make
@@ skipping 48 matching lines @@
 intptr_t PrctlHandler(const struct arch_seccomp_data& args, void*) {
   if (args.args[0] == PR_CAPBSET_DROP && static_cast<int>(args.args[1]) == -1) {
     // prctl(PR_CAPBSET_DROP, -1) is never valid. The kernel will always
     // return an error. But our handler allows this call.
     return 0;
   } else {
     return SandboxBPF::ForwardSyscall(args);
   }
 }
 
-class PrctlPolicy : public SandboxBPFDSLPolicy {
+class PrctlPolicy : public Policy {
  public:
   PrctlPolicy() {}
   virtual ~PrctlPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override {
     DCHECK(SandboxBPF::IsValidSyscallNumber(sysno));
     setenv(kSandboxDebuggingEnv, "t", 0);
     Die::SuppressInfoMessages(true);
 
     if (sysno == __NR_prctl) {
@@ skipping 33 matching lines @@
   // unaffected by our policy.
   struct utsname uts = {};
   BPF_ASSERT(!uname(&uts));
   BPF_ASSERT(!strcmp(uts.sysname, "Linux"));
 }
 
 intptr_t AllowRedirectedSyscall(const struct arch_seccomp_data& args, void*) {
   return SandboxBPF::ForwardSyscall(args);
 }
 
-class RedirectAllSyscallsPolicy : public SandboxBPFDSLPolicy {
+class RedirectAllSyscallsPolicy : public Policy {
  public:
   RedirectAllSyscallsPolicy() {}
   virtual ~RedirectAllSyscallsPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RedirectAllSyscallsPolicy);
 };
 
@@ skipping 143 matching lines @@
       // the openat() system call.
       BPF_ASSERT(static_cast<int>(args.args[0]) == AT_FDCWD);
       return broker_process->Open(reinterpret_cast<const char*>(args.args[1]),
                                   static_cast<int>(args.args[2]));
     default:
       BPF_ASSERT(false);
       return -ENOSYS;
   }
 }
 
-class DenyOpenPolicy : public SandboxBPFDSLPolicy {
+class DenyOpenPolicy : public Policy {
  public:
   explicit DenyOpenPolicy(InitializedOpenBroker* iob) : iob_(iob) {}
   virtual ~DenyOpenPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override {
     DCHECK(SandboxBPF::IsValidSyscallNumber(sysno));
 
     switch (sysno) {
       case __NR_faccessat:
 #if defined(__NR_access)
@@ skipping 59 matching lines @@
   int cpu_info_access = access("/proc/cpuinfo", R_OK);
   BPF_ASSERT(cpu_info_access == 0);
   int cpu_info_fd = open("/proc/cpuinfo", O_RDONLY);
   BPF_ASSERT(cpu_info_fd >= 0);
   char buf[1024];
   BPF_ASSERT(read(cpu_info_fd, buf, sizeof(buf)) > 0);
 }
 
 // Simple test demonstrating how to use SandboxBPF::Cond()
 
-class SimpleCondTestPolicy : public SandboxBPFDSLPolicy {
+class SimpleCondTestPolicy : public Policy {
  public:
   SimpleCondTestPolicy() {}
   virtual ~SimpleCondTestPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SimpleCondTestPolicy);
 };
 
@@ skipping 336 matching lines @@
   // increased too much, the test will start failing.
 #if defined(__aarch64__)
   static const int kNumTestCases = 30;
 #else
   static const int kNumTestCases = 40;
 #endif
   static const int kMaxFanOut = 3;
   static const int kMaxArgs = 6;
 };
 
-class EqualityStressTestPolicy : public SandboxBPFDSLPolicy {
+class EqualityStressTestPolicy : public Policy {
  public:
   explicit EqualityStressTestPolicy(EqualityStressTest* aux) : aux_(aux) {}
   virtual ~EqualityStressTestPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override {
     return aux_->Policy(sysno);
   }
 
  private:
   EqualityStressTest* aux_;
 
   DISALLOW_COPY_AND_ASSIGN(EqualityStressTestPolicy);
 };
 
 BPF_TEST(SandboxBPF,
          EqualityTests,
          EqualityStressTestPolicy,
          EqualityStressTest /* (*BPF_AUX) */) {
   BPF_AUX->VerifyFilter();
 }
 
-class EqualityArgumentWidthPolicy : public SandboxBPFDSLPolicy {
+class EqualityArgumentWidthPolicy : public Policy {
  public:
   EqualityArgumentWidthPolicy() {}
   virtual ~EqualityArgumentWidthPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(EqualityArgumentWidthPolicy);
 };
 
@@ skipping 32 matching lines @@
 // syscall interface. So, we have to skip the part of the test that requires
 // 64bit arguments.
 BPF_DEATH_TEST_C(SandboxBPF,
                  EqualityArgumentUnallowed64bit,
                  DEATH_MESSAGE("Unexpected 64bit argument detected"),
                  EqualityArgumentWidthPolicy) {
   Syscall::Call(__NR_uname, 0, 0x5555555555555555ULL);
 }
 #endif
 
-class EqualityWithNegativeArgumentsPolicy : public SandboxBPFDSLPolicy {
+class EqualityWithNegativeArgumentsPolicy : public Policy {
  public:
   EqualityWithNegativeArgumentsPolicy() {}
   virtual ~EqualityWithNegativeArgumentsPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override {
     DCHECK(SandboxBPF::IsValidSyscallNumber(sysno));
     if (sysno == __NR_uname) {
       // TODO(mdempsky): This currently can't be Arg<int> because then
       // 0xFFFFFFFF will be treated as a (signed) int, and then when
       // Arg::EqualTo casts it to uint64_t, it will be sign extended.
@@ skipping 20 matching lines @@
                  EqualityWithNegative64bitArguments,
                  DEATH_MESSAGE("Unexpected 64bit argument detected"),
                  EqualityWithNegativeArgumentsPolicy) {
   // When expecting a 32bit system call argument, we look at the MSB of the
   // 64bit value and allow both "0" and "-1". But the latter is allowed only
   // iff the LSB was negative. So, this death test should error out.
   BPF_ASSERT(Syscall::Call(__NR_uname, 0xFFFFFFFF00000000LL) == -1);
 }
 #endif
 
-class AllBitTestPolicy : public SandboxBPFDSLPolicy {
+class AllBitTestPolicy : public Policy {
  public:
   AllBitTestPolicy() {}
   virtual ~AllBitTestPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override;
 
  private:
   static ResultExpr HasAllBits32(uint32_t bits);
   static ResultExpr HasAllBits64(uint64_t bits);
 
@@ skipping 165 matching lines @@
   // 64bit test: all of 0x100000001
   BITMASK_TEST(10,       0x000000000LL, ALLBITS64,0x100000001, EXPECT_FAILURE);
   BITMASK_TEST(10,       0x000000001LL, ALLBITS64,0x100000001, EXPECT_FAILURE);
   BITMASK_TEST(10,       0x100000000LL, ALLBITS64,0x100000001, EXPECT_FAILURE);
   BITMASK_TEST(10,       0x100000001LL, ALLBITS64,0x100000001, EXPT64_SUCCESS);
   BITMASK_TEST(10,         0xFFFFFFFFU, ALLBITS64,0x100000001, EXPECT_FAILURE);
   BITMASK_TEST(10,                 -1L, ALLBITS64,0x100000001, EXPT64_SUCCESS);
 #endif
 }
 
-class AnyBitTestPolicy : public SandboxBPFDSLPolicy {
+class AnyBitTestPolicy : public Policy {
  public:
   AnyBitTestPolicy() {}
   virtual ~AnyBitTestPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override;
 
  private:
   static ResultExpr HasAnyBits32(uint32_t);
   static ResultExpr HasAnyBits64(uint64_t);
 
@@ skipping 143 matching lines @@
   // 64bit test: any of 0x100000001
   BITMASK_TEST( 10,      0x000000000LL, ANYBITS64,0x100000001, EXPECT_FAILURE);
   BITMASK_TEST( 10,      0x000000001LL, ANYBITS64,0x100000001, EXPECT_SUCCESS);
   BITMASK_TEST( 10,      0x100000000LL, ANYBITS64,0x100000001, EXPT64_SUCCESS);
   BITMASK_TEST( 10,      0x100000001LL, ANYBITS64,0x100000001, EXPECT_SUCCESS);
   BITMASK_TEST( 10,        0xFFFFFFFFU, ANYBITS64,0x100000001, EXPECT_SUCCESS);
   BITMASK_TEST( 10,                -1L, ANYBITS64,0x100000001, EXPECT_SUCCESS);
 #endif
 }
 
-class MaskedEqualTestPolicy : public SandboxBPFDSLPolicy {
+class MaskedEqualTestPolicy : public Policy {
  public:
   MaskedEqualTestPolicy() {}
   virtual ~MaskedEqualTestPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override;
 
  private:
   static ResultExpr MaskedEqual32(uint32_t mask, uint32_t value);
   static ResultExpr MaskedEqual64(uint64_t mask, uint64_t value);
 
@@ skipping 106 matching lines @@
         (long long)args.args[1],
         (long long)args.args[2],
         (long long)args.args[3],
         (long long)args.args[4],
         (long long)args.args[5],
         msg);
   }
   return -EPERM;
 }
 
-class PthreadPolicyEquality : public SandboxBPFDSLPolicy {
+class PthreadPolicyEquality : public Policy {
  public:
   PthreadPolicyEquality() {}
   virtual ~PthreadPolicyEquality() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PthreadPolicyEquality);
 };
 
@@ skipping 23 matching lines @@
     const Arg<unsigned long> flags(0);
     return If(flags == kGlibcCloneMask ||
                   flags == (kBaseAndroidCloneMask | CLONE_DETACHED) ||
                   flags == kBaseAndroidCloneMask,
               Allow()).Else(Trap(PthreadTrapHandler, "Unknown mask"));
   }
 
   return Allow();
 }
 
-class PthreadPolicyBitMask : public SandboxBPFDSLPolicy {
+class PthreadPolicyBitMask : public Policy {
  public:
   PthreadPolicyBitMask() {}
   virtual ~PthreadPolicyBitMask() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override;
 
  private:
   static BoolExpr HasAnyBits(const Arg<unsigned long>& arg, unsigned long bits);
   static BoolExpr HasAllBits(const Arg<unsigned long>& arg, unsigned long bits);
 
@@ skipping 150 matching lines @@
   // PTRACE_SET_SYSCALL may not be in the enum.
   return syscall(__NR_ptrace, PTRACE_SET_SYSCALL, pid, NULL, syscall_number);
 #endif
 
   SECCOMP_PT_SYSCALL(*regs) = syscall_number;
   return 0;
 }
 
 const uint16_t kTraceData = 0xcc;
 
-class TraceAllPolicy : public SandboxBPFDSLPolicy {
+class TraceAllPolicy : public Policy {
  public:
   TraceAllPolicy() {}
   virtual ~TraceAllPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int system_call_number) const override {
     return Trace(kTraceData);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TraceAllPolicy);
@@ skipping 125 matching lines @@
     }
     count -= transfered;
     buffer += transfered;
     offset += transfered;
   }
   return true;
 }
 
 bool pread_64_was_forwarded = false;
 
-class TrapPread64Policy : public SandboxBPFDSLPolicy {
+class TrapPread64Policy : public Policy {
  public:
   TrapPread64Policy() {}
   virtual ~TrapPread64Policy() {}
 
   virtual ResultExpr EvaluateSyscall(int system_call_number) const override {
     // Set the global environment for unsafe traps once.
     if (system_call_number == MIN_SYSCALL) {
       EnableUnsafeTraps();
     }
 
@@ skipping 76 matching lines @@
   // This thread should have the filter applied as well.
   BlacklistNanosleepPolicy::AssertNanosleepFails();
 
   // Signal the condition to invoke the system call.
   event.Signal();
 
   // Wait for the thread to finish.
   BPF_ASSERT_EQ(0, pthread_join(thread, NULL));
 }
 
-class AllowAllPolicy : public SandboxBPFDSLPolicy {
+class AllowAllPolicy : public Policy {
  public:
   AllowAllPolicy() {}
   virtual ~AllowAllPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override {
     return Allow();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AllowAllPolicy);
@@ skipping 23 matching lines @@
   sandbox.SetSandboxPolicy(new AllowAllPolicy());
   BPF_ASSERT(!sandbox.StartSandbox(SandboxBPF::PROCESS_MULTI_THREADED));
 }
 #endif  // !defined(THREAD_SANITIZER)
 
 // A stub handler for the UnsafeTrap. Never called.
 intptr_t NoOpHandler(const struct arch_seccomp_data& args, void*) {
   return -1;
 }
 
-class UnsafeTrapWithCondPolicy : public SandboxBPFDSLPolicy {
+class UnsafeTrapWithCondPolicy : public Policy {
  public:
   UnsafeTrapWithCondPolicy() {}
   virtual ~UnsafeTrapWithCondPolicy() {}
 
   virtual ResultExpr EvaluateSyscall(int sysno) const override {
     DCHECK(SandboxBPF::IsValidSyscallNumber(sysno));
     setenv(kSandboxDebuggingEnv, "t", 0);
     Die::SuppressInfoMessages(true);
 
     if (SandboxBPF::IsRequiredForUnsafeTrap(sysno))
@@ skipping 40 matching lines @@
   BPF_ASSERT_EQ(ENOSYS, errno);
 
   BPF_ASSERT_EQ(-1, syscall(__NR_setgid, 300));
   BPF_ASSERT_EQ(EPERM, errno);
 }
 
 }  // namespace
 
 }  // namespace bpf_dsl
 }  // namespace sandbox