[MIPS] Add seccomp bpf support

sandbox/linux/seccomp-bpf/syscall.h

 // 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.
 
 #ifndef SANDBOX_LINUX_SECCOMP_BPF_SYSCALL_H__
 #define SANDBOX_LINUX_SECCOMP_BPF_SYSCALL_H__
 
+#include <signal.h>
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "sandbox/sandbox_export.h"
 
+// Android's signal.h doesn't define ucontext etc.
+#if defined(OS_ANDROID)
+#include "sandbox/linux/services/android_ucontext.h"
+#endif
+
 namespace sandbox {
 
 // This purely static class can be used to perform system calls with some
 // low-level control.
 class SANDBOX_EXPORT Syscall {
  public:
   // System calls can take up to six parameters (up to eight on some
   // architectures). Traditionally, glibc
   // implements this property by using variadic argument lists. This works, but
   // confuses modern tools such as valgrind, because we are nominally passing
@@ skipping 82 matching lines @@
 
   template <class T0>
   static inline intptr_t Call(int nr, T0 p0) {
     return Call(nr, p0, 0, 0, 0, 0, 0, 0, 0);
   }
 
   static inline intptr_t Call(int nr) {
     return Call(nr, 0, 0, 0, 0, 0, 0, 0, 0);
   }
 
+  // Set the registers in |ctx| to match what they would be after a system call
+  // returning |ret_val|. |ret_val| must follow the Syscall::Call() convention
+  // of being -errno on errors.
+  static void PutValueInUcontext(intptr_t ret_val, ucontext_t* ctx);
+
  private:
   // This performs system call |nr| with the arguments p0 to p7 from a constant
   // userland address, which is for instance observable by seccomp-bpf filters.
   // The constant userland address from which these system calls are made will
   // be returned if |nr| is passed as -1.
   // On error, this function will return a value between -1 and -4095 which
   // should be interpreted as -errno.
   static intptr_t Call(int nr,
                        intptr_t p0,
                        intptr_t p1,
                        intptr_t p2,
                        intptr_t p3,
                        intptr_t p4,
                        intptr_t p5,
                        intptr_t p6,
                        intptr_t p7);
 
+#if defined(__mips__)
+  // This function basically does on MIPS what SandboxSyscall() is doing on
+  // other architectures. However, because of specificity of MIPS regarding
+  // handling syscall errors, SandboxSyscall() is made as a wrapper for this
+  // function in order for SandboxSyscall() to behave more like on other
+  // architectures on places where return value from SandboxSyscall() is used
+  // directly (like in most tests).
+  // The syscall "nr" is called with arguments that are set in an array on which
+  // pointer "args" points to and an information weather there is an error or no
+  // is returned to SandboxSyscall() by err_stat.
+  static intptr_t SandboxSyscallRaw(int nr,
+                                    const intptr_t* args,
+                                    intptr_t* err_stat);
+#endif  // defined(__mips__)
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(Syscall);
 };
 
 }  // namespace sandbox
 
 #endif  // SANDBOX_LINUX_SECCOMP_BPF_SYSCALL_H__