WIP: Non-SFI mode: Enable nacl_helper_nonsfi_unittests.

sandbox/linux/tests/unit_tests.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 <fcntl.h>
 #include <poll.h>
 #include <signal.h>
 #include <stdio.h>
 #include <sys/resource.h>
+#include <sys/types.h>
+#include <sys/wait.h>
 #include <sys/time.h>
 #include <time.h>
 #include <unistd.h>
 
 #include "base/debug/leak_annotations.h"
 #include "base/files/file_util.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/third_party/valgrind/valgrind.h"
 #include "build/build_config.h"
 #include "sandbox/linux/tests/unit_tests.h"
 
+#if !defined(POLLRDHUP)
+#define POLLRDHUP 0x2000
+#endif
+
 namespace {
 std::string TestFailedMessage(const std::string& msg) {
   return msg.empty() ? std::string() : "Actual test failure: " + msg;
 }
 
 int GetSubProcessTimeoutTimeInSeconds() {
   // 10s ought to be enough for anybody.
   return 10;
 }
 
@@ skipping 29 matching lines @@
 #endif
 }
 
 // TODO(jln): figure out why base/.../dynamic_annotations.h's
 // RunningOnValgrind() cannot link.
 bool IsRunningOnValgrind() { return RUNNING_ON_VALGRIND; }
 
 static const int kExpectedValue = 42;
 static const int kIgnoreThisTest = 43;
 static const int kExitWithAssertionFailure = 1;
+#if !defined(OS_NACL_NONSFI)
 static const int kExitForTimeout = 2;
+#endif
 
-#if !defined(OS_ANDROID)
+#if !defined(OS_ANDROID) && !defined(OS_NACL_NONSFI)
 // This is due to StackDumpSignalHandler() performing _exit(1).
 // TODO(jln): get rid of the collision with kExitWithAssertionFailure.
 const int kExitAfterSIGSEGV = 1;
 #endif
 
+// PNaCl toolchain's signal ABIs are incompatible with Linux's.
+// So, for simplicity, we just drop the "timeout" feature from unittest
+// framework.
+#if !defined(OS_NACL_NONSFI)
 static void SigAlrmHandler(int) {
   const char failure_message[] = "Timeout reached!\n";
   // Make sure that we never block here.
   if (!fcntl(2, F_SETFL, O_NONBLOCK)) {
     ignore_result(write(2, failure_message, sizeof(failure_message) - 1));
   }
   _exit(kExitForTimeout);
 }
 
 // Set a timeout with a handler that will automatically fail the
@@ skipping 11 matching lines @@
   // is expecting to handle SIGALRM.
   SANDBOX_ASSERT((old_act.sa_flags & SA_SIGINFO) == 0);
   SANDBOX_ASSERT(old_act.sa_handler == SIG_DFL);
   sigset_t sigalrm_set;
   SANDBOX_ASSERT(sigemptyset(&sigalrm_set) == 0);
   SANDBOX_ASSERT(sigaddset(&sigalrm_set, SIGALRM) == 0);
   SANDBOX_ASSERT(sigprocmask(SIG_UNBLOCK, &sigalrm_set, NULL) == 0);
   SANDBOX_ASSERT(alarm(time_in_seconds) == 0);  // There should be no previous
                                                 // alarm.
 }
+#endif  // !defined(OS_NACL_NONSFI)
 
 // Runs a test in a sub-process. This is necessary for most of the code
 // in the BPF sandbox, as it potentially makes global state changes and as
 // it also tends to raise fatal errors, if the code has been used in an
 // insecure manner.
 void UnitTests::RunTestInProcess(SandboxTestRunner* test_runner,
                                  DeathCheck death,
                                  const void* death_aux) {
   CHECK(test_runner);
   // We need to fork(), so we can't be multi-threaded, as threads could hold
@@ skipping 36 matching lines @@
   if (!pid) {
     // In child process
     // Redirect stderr to our pipe. This way, we can capture all error
     // messages, if we decide we want to do so in our tests.
     SANDBOX_ASSERT(dup2(fds[1], 2) == 2);
     SANDBOX_ASSERT(!close(fds[0]));
     SANDBOX_ASSERT(!close(fds[1]));
 
     // Don't set a timeout if running on Valgrind, since it's generally much
     // slower.
+#if !defined(OS_NACL_NONSFI)
     if (!IsRunningOnValgrind()) {
       SetProcessTimeout(GetSubProcessTimeoutTimeInSeconds());
     }
+#endif
 
     // Disable core files. They are not very useful for our individual test
     // cases.
     struct rlimit no_core = {0};
     setrlimit(RLIMIT_CORE, &no_core);
 
     test_runner->Run();
     if (test_runner->ShouldCheckForLeaks()) {
 #if defined(LEAK_SANITIZER)
       __lsan_do_leak_check();
@@ skipping 97 matching lines @@
 #endif
   EXPECT_FALSE(subprocess_exited_without_matching_message) << details;
 }
 
 void UnitTests::DeathSEGVMessage(int status,
                                  const std::string& msg,
                                  const void* aux) {
   std::string details(TestFailedMessage(msg));
   const char* expected_msg = static_cast<const char*>(aux);
 
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(OS_NACL_NONSFI)
   const bool subprocess_got_sigsegv =
       WIFSIGNALED(status) && (SIGSEGV == WTERMSIG(status));
 #else
   const bool subprocess_got_sigsegv =
       WIFEXITED(status) && (kExitAfterSIGSEGV == WEXITSTATUS(status));
 #endif
 
   ASSERT_TRUE(subprocess_got_sigsegv) << "Exit status: " << status
                                       << " " << details;
 
@@ skipping 31 matching lines @@
   fflush(stderr);
   _exit(kExitWithAssertionFailure);
 }
 
 void UnitTests::IgnoreThisTest() {
   fflush(stderr);
   _exit(kIgnoreThisTest);
 }
 
 }  // namespace