1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
9 #include <sys/resource.h>
14 #include "base/debug/leak_annotations.h"
15 #include "base/file_util.h"
16 #include "base/posix/eintr_wrapper.h"
17 #include "base/third_party/valgrind/valgrind.h"
18 #include "build/build_config.h"
19 #include "sandbox/linux/tests/unit_tests.h"
22 std::string
TestFailedMessage(const std::string
& msg
) {
23 return msg
.empty() ? std::string() : "Actual test failure: " + msg
;
26 int GetSubProcessTimeoutTimeInSeconds() {
27 // 10s ought to be enough for anybody.
31 // Returns the number of threads of the current process or -1.
33 struct stat task_stat
;
34 int task_d
= stat("/proc/self/task", &task_stat
);
35 // task_stat.st_nlink should be the number of tasks + 2 (accounting for
37 if (task_d
!= 0 || task_stat
.st_nlink
< 3)
39 const int num_threads
= task_stat
.st_nlink
- 2;
48 #if defined(OS_ANDROID)
55 bool IsArchitectureArm() {
56 #if defined(ARCH_CPU_ARM_FAMILY)
63 // TODO(jln): figure out why base/.../dynamic_annotations.h's
64 // RunningOnValgrind() cannot link.
65 bool IsRunningOnValgrind() { return RUNNING_ON_VALGRIND
; }
67 static const int kExpectedValue
= 42;
68 static const int kIgnoreThisTest
= 43;
69 static const int kExitWithAssertionFailure
= 1;
70 static const int kExitForTimeout
= 2;
72 #if !defined(OS_ANDROID)
73 // This is due to StackDumpSignalHandler() performing _exit(1).
74 // TODO(jln): get rid of the collision with kExitWithAssertionFailure.
75 const int kExitAfterSIGSEGV
= 1;
78 static void SigAlrmHandler(int) {
79 const char failure_message
[] = "Timeout reached!\n";
80 // Make sure that we never block here.
81 if (!fcntl(2, F_SETFL
, O_NONBLOCK
)) {
82 ignore_result(write(2, failure_message
, sizeof(failure_message
) - 1));
84 _exit(kExitForTimeout
);
87 // Set a timeout with a handler that will automatically fail the
89 static void SetProcessTimeout(int time_in_seconds
) {
90 struct sigaction act
= {};
91 act
.sa_handler
= SigAlrmHandler
;
92 SANDBOX_ASSERT(sigemptyset(&act
.sa_mask
) == 0);
95 struct sigaction old_act
;
96 SANDBOX_ASSERT(sigaction(SIGALRM
, &act
, &old_act
) == 0);
98 // We don't implemenet signal chaining, so make sure that nothing else
99 // is expecting to handle SIGALRM.
100 SANDBOX_ASSERT((old_act
.sa_flags
& SA_SIGINFO
) == 0);
101 SANDBOX_ASSERT(old_act
.sa_handler
== SIG_DFL
);
102 sigset_t sigalrm_set
;
103 SANDBOX_ASSERT(sigemptyset(&sigalrm_set
) == 0);
104 SANDBOX_ASSERT(sigaddset(&sigalrm_set
, SIGALRM
) == 0);
105 SANDBOX_ASSERT(sigprocmask(SIG_UNBLOCK
, &sigalrm_set
, NULL
) == 0);
106 SANDBOX_ASSERT(alarm(time_in_seconds
) == 0); // There should be no previous
110 // Runs a test in a sub-process. This is necessary for most of the code
111 // in the BPF sandbox, as it potentially makes global state changes and as
112 // it also tends to raise fatal errors, if the code has been used in an
114 void UnitTests::RunTestInProcess(SandboxTestRunner
* test_runner
,
116 const void* death_aux
) {
118 // We need to fork(), so we can't be multi-threaded, as threads could hold
120 int num_threads
= CountThreads();
121 #if !defined(THREAD_SANITIZER)
122 const int kNumExpectedThreads
= 1;
124 // Under TSAN, there is a special helper thread. It should be completely
125 // invisible to our testing, so we ignore it. It should be ok to fork()
126 // with this thread. It's currently buggy, but it's the best we can do until
127 // there is a way to delay the start of the thread
128 // (https://code.google.com/p/thread-sanitizer/issues/detail?id=19).
129 const int kNumExpectedThreads
= 2;
132 // The kernel is at liberty to wake a thread id futex before updating /proc.
133 // If another test running in the same process has stopped a thread, it may
134 // appear as still running in /proc.
135 // We poll /proc, with an exponential back-off. At most, we'll sleep around
136 // 2^iterations nanoseconds in nanosleep().
137 for (unsigned int iteration
= 0; iteration
< 30; iteration
++) {
138 struct timespec ts
= {0, 1L << iteration
/* nanoseconds */};
139 PCHECK(0 == HANDLE_EINTR(nanosleep(&ts
, &ts
)));
140 num_threads
= CountThreads();
141 if (kNumExpectedThreads
== num_threads
)
145 ASSERT_EQ(kNumExpectedThreads
, num_threads
)
146 << "Running sandbox tests with multiple threads "
147 << "is not supported and will make the tests flaky.";
149 ASSERT_EQ(0, pipe(fds
));
150 // Check that our pipe is not on one of the standard file descriptor.
151 SANDBOX_ASSERT(fds
[0] > 2 && fds
[1] > 2);
154 ASSERT_LE(0, (pid
= fork()));
157 // Redirect stderr to our pipe. This way, we can capture all error
158 // messages, if we decide we want to do so in our tests.
159 SANDBOX_ASSERT(dup2(fds
[1], 2) == 2);
160 SANDBOX_ASSERT(!close(fds
[0]));
161 SANDBOX_ASSERT(!close(fds
[1]));
163 // Don't set a timeout if running on Valgrind, since it's generally much
165 if (!IsRunningOnValgrind()) {
166 SetProcessTimeout(GetSubProcessTimeoutTimeInSeconds());
169 // Disable core files. They are not very useful for our individual test
171 struct rlimit no_core
= {0};
172 setrlimit(RLIMIT_CORE
, &no_core
);
175 if (test_runner
->ShouldCheckForLeaks()) {
176 #if defined(LEAK_SANITIZER)
177 __lsan_do_leak_check();
180 _exit(kExpectedValue
);
184 std::vector
<char> msg_buf
;
187 // Make sure read() will never block as we'll use poll() to
188 // block with a timeout instead.
189 const int fcntl_ret
= fcntl(fds
[0], F_SETFL
, O_NONBLOCK
);
190 ASSERT_EQ(0, fcntl_ret
);
191 struct pollfd poll_fd
= {fds
[0], POLLIN
| POLLRDHUP
, 0};
194 // We prefer the SIGALRM timeout to trigger in the child than this timeout
195 // so we double the common value here.
196 int poll_timeout
= GetSubProcessTimeoutTimeInSeconds() * 2 * 1000;
197 while ((poll_ret
= poll(&poll_fd
, 1, poll_timeout
) > 0)) {
198 const size_t kCapacity
= 256;
199 const size_t len
= msg_buf
.size();
200 msg_buf
.resize(len
+ kCapacity
);
201 rc
= HANDLE_EINTR(read(fds
[0], &msg_buf
[len
], kCapacity
));
202 msg_buf
.resize(len
+ std::max(rc
, static_cast<ssize_t
>(0)));
206 ASSERT_NE(poll_ret
, -1) << "poll() failed";
207 ASSERT_NE(poll_ret
, 0) << "Timeout while reading child state";
209 std::string
msg(msg_buf
.begin(), msg_buf
.end());
212 int waitpid_returned
= HANDLE_EINTR(waitpid(pid
, &status
, 0));
213 ASSERT_EQ(pid
, waitpid_returned
) << TestFailedMessage(msg
);
215 // At run-time, we sometimes decide that a test shouldn't actually
216 // run (e.g. when testing sandbox features on a kernel that doesn't
217 // have sandboxing support). When that happens, don't attempt to
218 // call the "death" function, as it might be looking for a
219 // death-test condition that would never have triggered.
220 if (!WIFEXITED(status
) || WEXITSTATUS(status
) != kIgnoreThisTest
||
222 // We use gtest's ASSERT_XXX() macros instead of the DeathCheck
223 // functions. This means, on failure, "return" is called. This
224 // only works correctly, if the call of the "death" callback is
225 // the very last thing in our function.
226 death(status
, msg
, death_aux
);
230 void UnitTests::DeathSuccess(int status
, const std::string
& msg
, const void*) {
231 std::string
details(TestFailedMessage(msg
));
233 bool subprocess_terminated_normally
= WIFEXITED(status
);
234 ASSERT_TRUE(subprocess_terminated_normally
) << details
;
235 int subprocess_exit_status
= WEXITSTATUS(status
);
236 ASSERT_EQ(kExpectedValue
, subprocess_exit_status
) << details
;
237 bool subprocess_exited_but_printed_messages
= !msg
.empty();
238 EXPECT_FALSE(subprocess_exited_but_printed_messages
) << details
;
241 void UnitTests::DeathSuccessAllowNoise(int status
,
242 const std::string
& msg
,
244 std::string
details(TestFailedMessage(msg
));
246 bool subprocess_terminated_normally
= WIFEXITED(status
);
247 ASSERT_TRUE(subprocess_terminated_normally
) << details
;
248 int subprocess_exit_status
= WEXITSTATUS(status
);
249 ASSERT_EQ(kExpectedValue
, subprocess_exit_status
) << details
;
252 void UnitTests::DeathMessage(int status
,
253 const std::string
& msg
,
255 std::string
details(TestFailedMessage(msg
));
256 const char* expected_msg
= static_cast<const char*>(aux
);
258 bool subprocess_terminated_normally
= WIFEXITED(status
);
259 ASSERT_TRUE(subprocess_terminated_normally
) << "Exit status: " << status
261 int subprocess_exit_status
= WEXITSTATUS(status
);
262 ASSERT_EQ(1, subprocess_exit_status
) << details
;
264 bool subprocess_exited_without_matching_message
=
265 msg
.find(expected_msg
) == std::string::npos
;
266 EXPECT_FALSE(subprocess_exited_without_matching_message
) << details
;
269 void UnitTests::DeathSEGVMessage(int status
,
270 const std::string
& msg
,
272 std::string
details(TestFailedMessage(msg
));
273 const char* expected_msg
= static_cast<const char*>(aux
);
275 #if defined(OS_ANDROID)
276 const bool subprocess_got_sigsegv
=
277 WIFSIGNALED(status
) && (SIGSEGV
== WTERMSIG(status
));
279 const bool subprocess_got_sigsegv
=
280 WIFEXITED(status
) && (kExitAfterSIGSEGV
== WEXITSTATUS(status
));
283 ASSERT_TRUE(subprocess_got_sigsegv
) << "Exit status: " << status
286 bool subprocess_exited_without_matching_message
=
287 msg
.find(expected_msg
) == std::string::npos
;
288 EXPECT_FALSE(subprocess_exited_without_matching_message
) << details
;
291 void UnitTests::DeathExitCode(int status
,
292 const std::string
& msg
,
294 int expected_exit_code
= static_cast<int>(reinterpret_cast<intptr_t>(aux
));
295 std::string
details(TestFailedMessage(msg
));
297 bool subprocess_terminated_normally
= WIFEXITED(status
);
298 ASSERT_TRUE(subprocess_terminated_normally
) << details
;
299 int subprocess_exit_status
= WEXITSTATUS(status
);
300 ASSERT_EQ(expected_exit_code
, subprocess_exit_status
) << details
;
303 void UnitTests::DeathBySignal(int status
,
304 const std::string
& msg
,
306 int expected_signo
= static_cast<int>(reinterpret_cast<intptr_t>(aux
));
307 std::string
details(TestFailedMessage(msg
));
309 bool subprocess_terminated_by_signal
= WIFSIGNALED(status
);
310 ASSERT_TRUE(subprocess_terminated_by_signal
) << details
;
311 int subprocess_signal_number
= WTERMSIG(status
);
312 ASSERT_EQ(expected_signo
, subprocess_signal_number
) << details
;
315 void UnitTests::AssertionFailure(const char* expr
, const char* file
, int line
) {
316 fprintf(stderr
, "%s:%d:%s", file
, line
, expr
);
318 _exit(kExitWithAssertionFailure
);
321 void UnitTests::IgnoreThisTest() {
323 _exit(kIgnoreThisTest
);