[MIPS] Add seccomp bpf support

sandbox/linux/services/kernel_to_errno.h

Index: sandbox/linux/services/kernel_to_errno.h
diff --git a/sandbox/linux/services/kernel_to_errno.h b/sandbox/linux/services/kernel_to_errno.h
new file mode 100644
index 0000000000000000000000000000000000000000..42f9299f2db2bd77ed0623c3f5b312bab4100b9e
--- /dev/null
+++ b/sandbox/linux/services/kernel_to_errno.h
@@ -0,0 +1,37 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.

[jln (very slow on Chromium), 2014/05/16 19:30:17]

- Please, add a _unittest.cc file for this with a least a few basic unit tests.

- Let's rename it something more generic like "kernel_return_value_helpers.h"
maybe?

[nedeljko, 2014/05/19 17:37:23]

These are pretty basic functions.

Since functions in this file are only converting values from positive to
negative and vice verse, I am not quit sure what should I test...

[jln (very slow on Chromium), 2014/05/20 01:57:47]

What should be tested is what these function do.

A. For ErrnoToKernelRet(), you could have a test that looks like this:

TEST(XXXX, ErrnoToKernelRet) {

  const int expected_kernel_ret = low_level_syscall(__NR_dup, -1);
  ASSERT_EQ(expected_kernel_ret, ErrnoToKernelRet(EBADF));
}

Of course it's problematic if you don't have a low_level_syscall()
implementation. You could want to use the one you added in seccomp-bpf, but
services/ should not depend on seccomp-bpf/.

Does the libc on MIPS give you anything? Any other approach you could think of?

You could also simply put this in seccomp-bpf/ instead and create a test that
uses the SandboxSyscall() function.

B. For PutValueInUcontext(), things seem more difficult.

- Is there anything clever to do with makecontext(3) and swapcontext(3)? It
seems hard.

- You could do a SANDBOX_TEST that does the following:
1. Create a new process with the sandbox::ScopedProcess class.
2. The child process runs a closure that does the following:
- set-up a new signal handler (for instance for SIGSYS). The signal handler uses
PutValueInUcontext() to put (for instance) EBADF as a return value in the
ucontext_t.
- the child calls int blah = syscall(__NR_pause);
Then the child checks "blah" to be -1 and errno and return an error code
depending on whether errno is "EBADF".

3. The parent signals the child with SIGSYS, then waits for it to exit. Then
checks that the return code for the child is correct.

This is a bit complicated. If you want I can write the unit test for Intel/ARM
and you can simply make sure it works for MIPS.

[nedeljko, 2014/05/20 14:36:41]

I was thinking to move this (implementation of functions in kernel_to_errno.h)
to seccomp-bpf anyhow since I will need macros from linux_seccomp.h file for
implementation of PutValueInUcontext(), so this
is probably the best approach.
I would appreciate if you are willing to do this.

Thanks.

[nedeljko, 2014/05/22 17:38:55]

Done.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SANDBOX_LINUX_SERVICES_KERNEL_TO_ERRNO_H
+#define SANDBOX_LINUX_SERVICES_KERNEL_TO_ERRNO_H
+
+namespace {

[jln (very slow on Chromium), 2014/05/16 19:30:17]

This should be "namespace sandbox".

[nedeljko, 2014/05/22 17:38:55]

Done.

+
+inline int KernelRetToErrno(int kernel_ret) {

[jln (very slow on Chromium), 2014/05/16 19:30:17]

In practice I've only seen this used taking an errno and returning a kernel
return value. Shouldn't this be ErrnoToKernelret() instead? It's possible that
we need both though.

[nedeljko, 2014/05/22 17:38:55]

Done.

+#if defined(__mips__)
+  // On MIPS, kernel returns kernel_ret (instead of -kernel_ret)
+  return kernel_ret;
+#else
+  return -kernel_ret;
+#endif
+}
+
+inline int RetValToKernelRet(int ret_val, ucontext_t* ctx) {

[jln (very slow on Chromium), 2014/05/16 19:30:17]

Please add valid #include for ucontext_t.

[jln (very slow on Chromium), 2014/05/16 19:30:17]

Let's make this a function that returns void instead.

Maybe "void PutValueInUcontext(int ret_val, ucontext_t* ctx)" ?

It should both set the return code to the valid value in the adequate register
and, on MIPS, also modify a3.

[jln (very slow on Chromium), 2014/05/16 21:27:10]

Let's have the implementation hidden in a .cc file instead of an inline
function.

We win very little by having the function inline and we win a lot by hiding the
implementation with proper #include and unit tests.

[nedeljko, 2014/05/22 17:38:55]

Done.

[nedeljko, 2014/05/22 17:38:55]

Done.

[nedeljko, 2014/05/22 17:38:55]

Done.

+#if defined(__mips__)
+  // Mips ABI states that on error a3 CPU register should be set to one
+  // and if there is no error, it should be zero.
+  if (ret_val < 0) {
+  // On MIPS, kernel returns errno (instead of -errno)
+    ret_val = -ret_val;
+    (ctx)->uc_mcontext.gregs[7] = 1;
+  } else
+    (ctx)->uc_mcontext.gregs[7] = 0;
+  return ret_val;
+#else
+  return ret_val;
+#endif
+}
+
+} // namespace
+
+#endif  // SANDBOX_LINUX_SERVICES_KERNEL_TO_ERRNO_H