Introduce sys_sigprocmask and sys_sigaction.

sandbox/linux/services/syscall_wrappers.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/services/syscall_wrappers.h"
 
 #include <pthread.h>
 #include <sched.h>
 #include <setjmp.h>
 #include <sys/resource.h>
 #include <sys/syscall.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/third_party/valgrind/valgrind.h"
 #include "build/build_config.h"
 #include "sandbox/linux/system_headers/capability.h"
+#include "sandbox/linux/system_headers/linux_signal.h"
 #include "sandbox/linux/system_headers/linux_syscalls.h"
 
 namespace sandbox {
 
 pid_t sys_getpid(void) {
   return syscall(__NR_getpid);
 }
 
 pid_t sys_gettid(void) {
   return syscall(__NR_gettid);
@@ skipping 99 matching lines @@
 }
 
 int sys_chroot(const char* path) {
   return syscall(__NR_chroot, path);
 }
 
 int sys_unshare(int flags) {
   return syscall(__NR_unshare, flags);
 }
 
+int sys_sigprocmask(
+    int how, const sigset_t* set, decltype(nullptr) oldset) {

[mdempsky, 2015/04/13 18:55:07]

Nit: This line breaking seems odd.  Can you please run "git cl format"?

[hidehiko, 2015/04/14 11:56:41]

Done.

+  // In some toolchain (in particular ANDROID and PNaCl toolchain),

[mdempsky, 2015/04/13 18:55:07]

Nit: Just "Android".

[hidehiko, 2015/04/14 11:56:41]

Done.

+  // sigset_t is 32 bits, but Linux ABI requires 64 bits.
+  uint64_t linux_value = 0;
+  std::memcpy(&linux_value, set, std::min(sizeof(sigset_t), sizeof(uint64_t)));

[mdempsky, 2015/04/13 18:55:07]

Nit: You need <cstring> for std::memcpy (or <string.h> for memcpy, which seems
more common in Chromium) and <algorithm> for std::min.

I'm also a little nervous about just using memcpy like this, because it makes
assumptions about how the libc defines sigset_t.  Can you add a unit test to
make sure this is safe?  E.g., just create a sigset_t, add a few signals with
sigaddset, memcpy to a uint64_t, and then check that it has the expected value.

[hidehiko, 2015/04/14 11:56:41]

Done.

+  return syscall(
+      __NR_rt_sigprocmask, how, &linux_value, nullptr, sizeof(linux_value));
+}
+
+// struct sigaction is different ABI from the Linux's.
+struct KernelSigAction {
+  void (*kernel_handler)(int);
+  uint32_t sa_flags;
+  void (*sa_restorer)(void);
+  uint64_t sa_mask;
+};
+
+// On X86_64 arch, it is necessary to set sa_restorer always.
+#if defined(ARCH_CPU_X86_64)
+#if !defined(SA_RESTORER)
+#define SA_RESTORER 0x04000000
+#endif
+
+static void sys_rt_sigreturn() {
+  syscall(__NR_rt_sigreturn);
+}
+#endif
+
+int sys_sigaction(int signum, const struct sigaction* act,
+                  struct sigaction* oldact) {
+  KernelSigAction kernel_act = {};
+  if (act) {
+    kernel_act.kernel_handler = act->sa_handler;
+    std::memcpy(&kernel_act.sa_mask, &act->sa_mask,
+                std::min(sizeof(kernel_act.sa_mask), sizeof(act->sa_mask)));
+    kernel_act.sa_flags = act->sa_flags;
+
+#if defined(ARCH_CPU_X86_64)
+    if (!(kernel_act.sa_flags & SA_RESTORER)) {
+      kernel_act.sa_flags |= SA_RESTORER;
+      kernel_act.sa_restorer = sys_rt_sigreturn;
+    }
+#endif
+  }
+
+  KernelSigAction kernel_oldact = {};
+  int result = syscall(
+      __NR_rt_sigaction, signum, act ? &kernel_act : nullptr,
+      oldact ? &kernel_oldact : nullptr, sizeof(uint64_t));
+  if (result == 0 && oldact) {
+    oldact->sa_handler = kernel_oldact.kernel_handler;
+    std::memcpy(&oldact->sa_mask, &kernel_oldact.sa_mask,

[mdempsky, 2015/04/13 18:55:07]

I think you also want to memset &oldact->sa_mask to 0 first in case
sizeof(sa_mask) > sizeof(uint64_t)?

[hidehiko, 2015/04/14 11:56:40]

Good catch. Done.

+                std::min(sizeof(kernel_act.sa_mask), sizeof(act->sa_mask)));
+    oldact->sa_flags = kernel_oldact.sa_flags;
+  }
+  return result;
+}
+
 }  // namespace sandbox