Update sandbox/linux from upstream

sandbox/linux/bpf_dsl/bpf_dsl.cc

 // Copyright 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 "sandbox/linux/bpf_dsl/bpf_dsl.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "sandbox/linux/bpf_dsl/bpf_dsl_impl.h"
+#include "sandbox/linux/bpf_dsl/errorcode.h"
 #include "sandbox/linux/bpf_dsl/policy_compiler.h"
-#include "sandbox/linux/seccomp-bpf/die.h"
-#include "sandbox/linux/seccomp-bpf/errorcode.h"
 
 namespace sandbox {
 namespace bpf_dsl {
 namespace {
 
-intptr_t BPFFailure(const struct arch_seccomp_data&, void* aux) {
-  SANDBOX_DIE(static_cast<char*>(aux));
-}
-
 class AllowResultExprImpl : public internal::ResultExprImpl {
  public:
   AllowResultExprImpl() {}
 
   ErrorCode Compile(PolicyCompiler* pc) const override {
     return ErrorCode(ErrorCode::ERR_ALLOWED);
   }
 
   bool IsAllow() const override { return true; }
 
@@ skipping 16 matching lines @@
   bool IsDeny() const override { return true; }
 
  private:
   ~ErrorResultExprImpl() override {}
 
   int err_;
 
   DISALLOW_COPY_AND_ASSIGN(ErrorResultExprImpl);
 };
 
+class KillResultExprImpl : public internal::ResultExprImpl {
+ public:
+  KillResultExprImpl() {}
+
+  ErrorCode Compile(PolicyCompiler* pc) const override {
+    return ErrorCode(ErrorCode::ERR_KILL);
+  }
+
+  bool IsDeny() const override { return true; }
+
+ private:
+  ~KillResultExprImpl() override {}
+
+  DISALLOW_COPY_AND_ASSIGN(KillResultExprImpl);
+};
+
 class TraceResultExprImpl : public internal::ResultExprImpl {
  public:
   TraceResultExprImpl(uint16_t aux) : aux_(aux) {}
 
   ErrorCode Compile(PolicyCompiler* pc) const override {
     return ErrorCode(ErrorCode::ERR_TRACE + aux_);
   }
 
  private:
   ~TraceResultExprImpl() override {}
@@ skipping 178 matching lines @@
       return std::numeric_limits<uint32_t>::max();
     case 8:
       return std::numeric_limits<uint64_t>::max();
     default:
       CHECK(false) << "Unimplemented DefaultMask case";
       return 0;
   }
 }
 
 BoolExpr ArgEq(int num, size_t size, uint64_t mask, uint64_t val) {
+  // If this is changed, update Arg<T>::EqualTo's static_cast rules
+  // accordingly.
   CHECK(size == 4 || size == 8);
 
   // TODO(mdempsky): Should we just always use TP_64BIT?
   const ErrorCode::ArgType arg_type =
       (size == 4) ? ErrorCode::TP_32BIT : ErrorCode::TP_64BIT;
 
   return BoolExpr(new const PrimitiveBoolExprImpl(num, arg_type, mask, val));
 }
 
 }  // namespace internal
 
 ResultExpr Allow() {
   return ResultExpr(new const AllowResultExprImpl());
 }
 
 ResultExpr Error(int err) {
   return ResultExpr(new const ErrorResultExprImpl(err));
 }
 
-ResultExpr Kill(const char* msg) {
-  return Trap(BPFFailure, msg);
+ResultExpr Kill() {
+  return ResultExpr(new const KillResultExprImpl());
 }
 
 ResultExpr Trace(uint16_t aux) {
   return ResultExpr(new const TraceResultExprImpl(aux));
 }
 
 ResultExpr Trap(TrapRegistry::TrapFnc trap_func, const void* aux) {
   return ResultExpr(
       new const TrapResultExprImpl(trap_func, aux, true /* safe */));
 }
@@ skipping 65 matching lines @@
         new const IfThenResultExprImpl(clause.first, clause.second, expr));
   }
   return expr;
 }
 
 }  // namespace bpf_dsl
 }  // namespace sandbox
 
 template class scoped_refptr<const sandbox::bpf_dsl::internal::BoolExprImpl>;
 template class scoped_refptr<const sandbox::bpf_dsl::internal::ResultExprImpl>;