Linux Sandbox: get everything to compile on Android.

sandbox/linux/seccomp-bpf/sandbox_bpf.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 <signal.h>
+#include <sys/syscall.h>
+
 #ifndef SECCOMP_BPF_STANDALONE
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #endif
 
 #include "sandbox/linux/seccomp-bpf/codegen.h"
 #include "sandbox/linux/seccomp-bpf/sandbox_bpf.h"
 #include "sandbox/linux/seccomp-bpf/syscall.h"
 #include "sandbox/linux/seccomp-bpf/syscall_iterator.h"
 #include "sandbox/linux/seccomp-bpf/verifier.h"
 
+// Android's signal.h doesn't define ucontext etc.
+#if defined(OS_ANDROID) && defined(__arm__)
+#include "sandbox/linux/services/android_arm_ucontext.h"
+#endif
+
 namespace {
 
 void WriteFailedStderrSetupMessage(int out_fd) {
   const char* error_string = strerror(errno);
   static const char msg[] = "You have reproduced a puzzling issue.\n"
                             "Please, report to crbug.com/152530!\n"
                             "Failed to set up stderr: ";
   if (HANDLE_EINTR(write(out_fd, msg, sizeof(msg)-1)) > 0 && error_string &&
       HANDLE_EINTR(write(out_fd, error_string, strlen(error_string))) > 0 &&
       HANDLE_EINTR(write(out_fd, "\n", 1))) {
   }
 }
 
 // We need to tell whether we are performing a "normal" callback, or
 // whether we were called recursively from within a UnsafeTrap() callback.
 // This is a little tricky to do, because we need to somehow get access to
 // per-thread data from within a signal context. Normal TLS storage is not
 // safely accessible at this time. We could roll our own, but that involves
 // a lot of complexity. Instead, we co-opt one bit in the signal mask.
 // If BUS is blocked, we assume that we have been called recursively.
 // There is a possibility for collision with other code that needs to do
 // this, but in practice the risks are low.
 // If SIGBUS turns out to be a problem, we could instead co-opt one of the
 // realtime signals. There are plenty of them. Unfortunately, there is no
 // way to mark a signal as allocated. So, the potential for collision is
 // possibly even worse.
-bool GetIsInSigHandler(const ucontext_t *ctx) {
+// Note: we can't use "const ucontext_t" because on Android, sigismember does
+// not take a pointer to const.
+bool GetIsInSigHandler(ucontext_t *ctx) {

[Markus (顧孟勤), 2012/12/19 00:44:54]

I probably would have left the function signature unchanged, as it looks more
correct with the "const". And I would then have performed a const_cast<>() in
the function body.

But it's really your call. I doesn't much matter either way.

[jln (very slow on Chromium), 2012/12/19 01:45:32]

I was worried that sigismember() might touch the sigmask, but it is crazy. Added
a const_cast.

   return sigismember(&ctx->uc_sigmask, SIGBUS);
 }
 
 void SetIsInSigHandler() {
   sigset_t mask;
   sigemptyset(&mask);
   sigaddset(&mask, SIGBUS);
   sigprocmask(SIG_BLOCK, &mask, NULL);
 }
 
@@ skipping 920 matching lines @@
 int Sandbox::proc_fd_                   = -1;
 Sandbox::Evaluators Sandbox::evaluators_;
 Sandbox::Traps *Sandbox::traps_         = NULL;
 Sandbox::TrapIds Sandbox::trap_ids_;
 ErrorCode *Sandbox::trap_array_         = NULL;
 size_t Sandbox::trap_array_size_        = 0;
   bool Sandbox::has_unsafe_traps_       = false;
 Sandbox::Conds Sandbox::conds_;
 
 }  // namespace