[MIPS] Add seccomp bpf support

sandbox/linux/seccomp-bpf/syscall_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 <asm/unistd.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
 #include <unistd.h>
 
@@ skipping 32 matching lines @@
 #if defined(__i386__)
   EXPECT_EQ(0x80CDu, ((uint16_t*)SandboxSyscall(-1))[-1]);  // INT 0x80
 #elif defined(__x86_64__)
   EXPECT_EQ(0x050Fu, ((uint16_t*)SandboxSyscall(-1))[-1]);  // SYSCALL
 #elif defined(__arm__)
 #if defined(__thumb__)
   EXPECT_EQ(0xDF00u, ((uint16_t*)SandboxSyscall(-1))[-1]);  // SWI 0
 #else
   EXPECT_EQ(0xEF000000u, ((uint32_t*)SandboxSyscall(-1))[-1]);  // SVC 0
 #endif
+#elif defined(__mips__)
+  // Opcode for MIPS sycall is in the lower 16-bits
+  EXPECT_EQ(0x0cu, (((uint32_t *)SandboxSyscall(-1))[-1])&0x0000FFFF);
 #else
 #warning Incomplete test case; need port for target platform
 #endif
 }
 
 TEST(Syscall, TrivialSyscallNoArgs) {
   // Test that we can do basic system calls
   EXPECT_EQ(SandboxSyscall(__NR_getpid), syscall(__NR_getpid));
 }
 
 TEST(Syscall, TrivialSyscallOneArg) {
   int new_fd;
   // Duplicate standard error and close it.
   ASSERT_GE(new_fd = SandboxSyscall(__NR_dup, 2), 0);
   int close_return_value = IGNORE_EINTR(SandboxSyscall(__NR_close, new_fd));
   ASSERT_EQ(close_return_value, 0);
 }
 
 // SIGSYS trap handler that will be called on __NR_uname.
 intptr_t CopySyscallArgsToAux(const struct arch_seccomp_data& args, void* aux) {
   // |aux| is a pointer to our BPF_AUX.
   std::vector<uint64_t>* const seen_syscall_args =
       static_cast<std::vector<uint64_t>*>(aux);
   BPF_ASSERT(arraysize(args.args) == 6);
   seen_syscall_args->assign(args.args, args.args + arraysize(args.args));
+#if defined(__mips__)
+  // On MIPS, kernel returns errno and not -errno
+  return ENOMEM;
+#else
   return -ENOMEM;
+#endif
 }
 
 ErrorCode CopyAllArgsOnUnamePolicy(SandboxBPF* sandbox, int sysno, void* aux) {
   if (!SandboxBPF::IsValidSyscallNumber(sysno)) {
     return ErrorCode(ENOSYS);
   }
   if (sysno == __NR_uname) {
     return sandbox->Trap(CopySyscallArgsToAux, aux);
   } else {
     return ErrorCode(ErrorCode::ERR_ALLOWED);
@@ skipping 11 matching lines @@
   // additional tests to try other types. What we will see depends on
   // implementation details of kernel BPF filters and we will need to document
   // the expected behavior very clearly.
   int syscall_args[6];
   for (size_t i = 0; i < arraysize(syscall_args); ++i) {
     syscall_args[i] = kExpectedValue + i;
   }
 
   // We could use pretty much any system call we don't need here. uname() is
   // nice because it doesn't have any dangerous side effects.
+#if defined(__mips__)
   BPF_ASSERT(SandboxSyscall(__NR_uname,
                             syscall_args[0],
                             syscall_args[1],
+                            syscall_args[2],
+                            syscall_args[3],
+                            syscall_args[4],
+                            syscall_args[5]) == ENOMEM);
+#else
+  BPF_ASSERT(SandboxSyscall(__NR_uname,
+                            syscall_args[0],
+                            syscall_args[1],
                             syscall_args[2],
                             syscall_args[3],
                             syscall_args[4],
                             syscall_args[5]) == -ENOMEM);
+#endif
 
   // We expect the trap handler to have copied the 6 arguments.
   BPF_ASSERT(BPF_AUX.size() == 6);
 
   // Don't loop here so that we can see which argument does cause the failure
   // easily from the failing line.
   // uint64_t is the type passed to our SIGSYS handler.
   BPF_ASSERT(BPF_AUX[0] == static_cast<uint64_t>(syscall_args[0]));
   BPF_ASSERT(BPF_AUX[1] == static_cast<uint64_t>(syscall_args[1]));
   BPF_ASSERT(BPF_AUX[2] == static_cast<uint64_t>(syscall_args[2]));
@@ skipping 65 matching lines @@
 
   // Clean up
   EXPECT_EQ(0, SandboxSyscall(__NR_munmap, addr2, 8192L));
   EXPECT_EQ(0, SandboxSyscall(__NR_munmap, addr3, 4096L));
   EXPECT_EQ(0, IGNORE_EINTR(SandboxSyscall(__NR_close, fd)));
 }
 
 }  // namespace
 
 }  // namespace sandbox