process_util_unittest.cc revision 46d4c2bc3267f3f028f39e7e311b0f89aba2e4fd
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. 4 5#define _CRT_SECURE_NO_WARNINGS 6 7#include <limits> 8 9#include "base/command_line.h" 10#include "base/debug/alias.h" 11#include "base/debug/stack_trace.h" 12#include "base/files/file_path.h" 13#include "base/logging.h" 14#include "base/memory/scoped_ptr.h" 15#include "base/path_service.h" 16#include "base/posix/eintr_wrapper.h" 17#include "base/process/kill.h" 18#include "base/process/launch.h" 19#include "base/process/memory.h" 20#include "base/process/process.h" 21#include "base/process/process_metrics.h" 22#include "base/strings/string_number_conversions.h" 23#include "base/strings/utf_string_conversions.h" 24#include "base/synchronization/waitable_event.h" 25#include "base/test/multiprocess_test.h" 26#include "base/test/test_timeouts.h" 27#include "base/third_party/dynamic_annotations/dynamic_annotations.h" 28#include "base/threading/platform_thread.h" 29#include "base/threading/thread.h" 30#include "testing/gtest/include/gtest/gtest.h" 31#include "testing/multiprocess_func_list.h" 32 33#if defined(OS_LINUX) 34#include <malloc.h> 35#include <sched.h> 36#endif 37#if defined(OS_POSIX) 38#include <dlfcn.h> 39#include <errno.h> 40#include <fcntl.h> 41#include <signal.h> 42#include <sys/resource.h> 43#include <sys/socket.h> 44#include <sys/wait.h> 45#endif 46#if defined(OS_WIN) 47#include <windows.h> 48#include "base/win/windows_version.h" 49#endif 50#if defined(OS_MACOSX) 51#include <mach/vm_param.h> 52#include <malloc/malloc.h> 53#endif 54 55using base::FilePath; 56 57namespace { 58 59#if defined(OS_ANDROID) 60const char kShellPath[] = "/system/bin/sh"; 61const char kPosixShell[] = "sh"; 62#else 63const char kShellPath[] = "/bin/sh"; 64const char kPosixShell[] = "bash"; 65#endif 66 67const char kSignalFileSlow[] = "SlowChildProcess.die"; 68const char kSignalFileKill[] = "KilledChildProcess.die"; 69 70#if defined(OS_WIN) 71const int kExpectedStillRunningExitCode = 0x102; 72const int kExpectedKilledExitCode = 1; 73#else 74const int kExpectedStillRunningExitCode = 0; 75#endif 76 77// Sleeps until file filename is created. 78void WaitToDie(const char* filename) { 79 FILE* fp; 80 do { 81 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10)); 82 fp = fopen(filename, "r"); 83 } while (!fp); 84 fclose(fp); 85} 86 87// Signals children they should die now. 88void SignalChildren(const char* filename) { 89 FILE* fp = fopen(filename, "w"); 90 fclose(fp); 91} 92 93// Using a pipe to the child to wait for an event was considered, but 94// there were cases in the past where pipes caused problems (other 95// libraries closing the fds, child deadlocking). This is a simple 96// case, so it's not worth the risk. Using wait loops is discouraged 97// in most instances. 98base::TerminationStatus WaitForChildTermination(base::ProcessHandle handle, 99 int* exit_code) { 100 // Now we wait until the result is something other than STILL_RUNNING. 101 base::TerminationStatus status = base::TERMINATION_STATUS_STILL_RUNNING; 102 const base::TimeDelta kInterval = base::TimeDelta::FromMilliseconds(20); 103 base::TimeDelta waited; 104 do { 105 status = base::GetTerminationStatus(handle, exit_code); 106 base::PlatformThread::Sleep(kInterval); 107 waited += kInterval; 108 } while (status == base::TERMINATION_STATUS_STILL_RUNNING && 109// Waiting for more time for process termination on android devices. 110#if defined(OS_ANDROID) 111 waited < TestTimeouts::large_test_timeout()); 112#else 113 waited < TestTimeouts::action_max_timeout()); 114#endif 115 116 return status; 117} 118 119} // namespace 120 121class ProcessUtilTest : public base::MultiProcessTest { 122 public: 123#if defined(OS_POSIX) 124 // Spawn a child process that counts how many file descriptors are open. 125 int CountOpenFDsInChild(); 126#endif 127 // Converts the filename to a platform specific filepath. 128 // On Android files can not be created in arbitrary directories. 129 static std::string GetSignalFilePath(const char* filename); 130}; 131 132std::string ProcessUtilTest::GetSignalFilePath(const char* filename) { 133#if !defined(OS_ANDROID) 134 return filename; 135#else 136 FilePath tmp_dir; 137 PathService::Get(base::DIR_CACHE, &tmp_dir); 138 tmp_dir = tmp_dir.Append(filename); 139 return tmp_dir.value(); 140#endif 141} 142 143MULTIPROCESS_TEST_MAIN(SimpleChildProcess) { 144 return 0; 145} 146 147// TODO(viettrungluu): This should be in a "MultiProcessTestTest". 148TEST_F(ProcessUtilTest, SpawnChild) { 149 base::ProcessHandle handle = SpawnChild("SimpleChildProcess"); 150 ASSERT_NE(base::kNullProcessHandle, handle); 151 EXPECT_TRUE(base::WaitForSingleProcess( 152 handle, TestTimeouts::action_max_timeout())); 153 base::CloseProcessHandle(handle); 154} 155 156MULTIPROCESS_TEST_MAIN(SlowChildProcess) { 157 WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileSlow).c_str()); 158 return 0; 159} 160 161TEST_F(ProcessUtilTest, KillSlowChild) { 162 const std::string signal_file = 163 ProcessUtilTest::GetSignalFilePath(kSignalFileSlow); 164 remove(signal_file.c_str()); 165 base::ProcessHandle handle = SpawnChild("SlowChildProcess"); 166 ASSERT_NE(base::kNullProcessHandle, handle); 167 SignalChildren(signal_file.c_str()); 168 EXPECT_TRUE(base::WaitForSingleProcess( 169 handle, TestTimeouts::action_max_timeout())); 170 base::CloseProcessHandle(handle); 171 remove(signal_file.c_str()); 172} 173 174// Times out on Linux and Win, flakes on other platforms, http://crbug.com/95058 175TEST_F(ProcessUtilTest, DISABLED_GetTerminationStatusExit) { 176 const std::string signal_file = 177 ProcessUtilTest::GetSignalFilePath(kSignalFileSlow); 178 remove(signal_file.c_str()); 179 base::ProcessHandle handle = SpawnChild("SlowChildProcess"); 180 ASSERT_NE(base::kNullProcessHandle, handle); 181 182 int exit_code = 42; 183 EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING, 184 base::GetTerminationStatus(handle, &exit_code)); 185 EXPECT_EQ(kExpectedStillRunningExitCode, exit_code); 186 187 SignalChildren(signal_file.c_str()); 188 exit_code = 42; 189 base::TerminationStatus status = 190 WaitForChildTermination(handle, &exit_code); 191 EXPECT_EQ(base::TERMINATION_STATUS_NORMAL_TERMINATION, status); 192 EXPECT_EQ(0, exit_code); 193 base::CloseProcessHandle(handle); 194 remove(signal_file.c_str()); 195} 196 197#if defined(OS_WIN) 198// TODO(cpu): figure out how to test this in other platforms. 199TEST_F(ProcessUtilTest, GetProcId) { 200 base::ProcessId id1 = base::GetProcId(GetCurrentProcess()); 201 EXPECT_NE(0ul, id1); 202 base::ProcessHandle handle = SpawnChild("SimpleChildProcess"); 203 ASSERT_NE(base::kNullProcessHandle, handle); 204 base::ProcessId id2 = base::GetProcId(handle); 205 EXPECT_NE(0ul, id2); 206 EXPECT_NE(id1, id2); 207 base::CloseProcessHandle(handle); 208} 209#endif 210 211#if !defined(OS_MACOSX) 212// This test is disabled on Mac, since it's flaky due to ReportCrash 213// taking a variable amount of time to parse and load the debug and 214// symbol data for this unit test's executable before firing the 215// signal handler. 216// 217// TODO(gspencer): turn this test process into a very small program 218// with no symbols (instead of using the multiprocess testing 219// framework) to reduce the ReportCrash overhead. 220const char kSignalFileCrash[] = "CrashingChildProcess.die"; 221 222MULTIPROCESS_TEST_MAIN(CrashingChildProcess) { 223 WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileCrash).c_str()); 224#if defined(OS_POSIX) 225 // Have to disable to signal handler for segv so we can get a crash 226 // instead of an abnormal termination through the crash dump handler. 227 ::signal(SIGSEGV, SIG_DFL); 228#endif 229 // Make this process have a segmentation fault. 230 volatile int* oops = NULL; 231 *oops = 0xDEAD; 232 return 1; 233} 234 235// This test intentionally crashes, so we don't need to run it under 236// AddressSanitizer. 237#if defined(ADDRESS_SANITIZER) || defined(SYZYASAN) 238#define MAYBE_GetTerminationStatusCrash DISABLED_GetTerminationStatusCrash 239#else 240#define MAYBE_GetTerminationStatusCrash GetTerminationStatusCrash 241#endif 242TEST_F(ProcessUtilTest, MAYBE_GetTerminationStatusCrash) { 243 const std::string signal_file = 244 ProcessUtilTest::GetSignalFilePath(kSignalFileCrash); 245 remove(signal_file.c_str()); 246 base::ProcessHandle handle = SpawnChild("CrashingChildProcess"); 247 ASSERT_NE(base::kNullProcessHandle, handle); 248 249 int exit_code = 42; 250 EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING, 251 base::GetTerminationStatus(handle, &exit_code)); 252 EXPECT_EQ(kExpectedStillRunningExitCode, exit_code); 253 254 SignalChildren(signal_file.c_str()); 255 exit_code = 42; 256 base::TerminationStatus status = 257 WaitForChildTermination(handle, &exit_code); 258 EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_CRASHED, status); 259 260#if defined(OS_WIN) 261 EXPECT_EQ(0xc0000005, exit_code); 262#elif defined(OS_POSIX) 263 int signaled = WIFSIGNALED(exit_code); 264 EXPECT_NE(0, signaled); 265 int signal = WTERMSIG(exit_code); 266 EXPECT_EQ(SIGSEGV, signal); 267#endif 268 base::CloseProcessHandle(handle); 269 270 // Reset signal handlers back to "normal". 271 base::debug::EnableInProcessStackDumping(); 272 remove(signal_file.c_str()); 273} 274#endif // !defined(OS_MACOSX) 275 276MULTIPROCESS_TEST_MAIN(KilledChildProcess) { 277 WaitToDie(ProcessUtilTest::GetSignalFilePath(kSignalFileKill).c_str()); 278#if defined(OS_WIN) 279 // Kill ourselves. 280 HANDLE handle = ::OpenProcess(PROCESS_ALL_ACCESS, 0, ::GetCurrentProcessId()); 281 ::TerminateProcess(handle, kExpectedKilledExitCode); 282#elif defined(OS_POSIX) 283 // Send a SIGKILL to this process, just like the OOM killer would. 284 ::kill(getpid(), SIGKILL); 285#endif 286 return 1; 287} 288 289TEST_F(ProcessUtilTest, GetTerminationStatusKill) { 290 const std::string signal_file = 291 ProcessUtilTest::GetSignalFilePath(kSignalFileKill); 292 remove(signal_file.c_str()); 293 base::ProcessHandle handle = SpawnChild("KilledChildProcess"); 294 ASSERT_NE(base::kNullProcessHandle, handle); 295 296 int exit_code = 42; 297 EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING, 298 base::GetTerminationStatus(handle, &exit_code)); 299 EXPECT_EQ(kExpectedStillRunningExitCode, exit_code); 300 301 SignalChildren(signal_file.c_str()); 302 exit_code = 42; 303 base::TerminationStatus status = 304 WaitForChildTermination(handle, &exit_code); 305 EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_WAS_KILLED, status); 306#if defined(OS_WIN) 307 EXPECT_EQ(kExpectedKilledExitCode, exit_code); 308#elif defined(OS_POSIX) 309 int signaled = WIFSIGNALED(exit_code); 310 EXPECT_NE(0, signaled); 311 int signal = WTERMSIG(exit_code); 312 EXPECT_EQ(SIGKILL, signal); 313#endif 314 base::CloseProcessHandle(handle); 315 remove(signal_file.c_str()); 316} 317 318// Ensure that the priority of a process is restored correctly after 319// backgrounding and restoring. 320// Note: a platform may not be willing or able to lower the priority of 321// a process. The calls to SetProcessBackground should be noops then. 322TEST_F(ProcessUtilTest, SetProcessBackgrounded) { 323 base::ProcessHandle handle = SpawnChild("SimpleChildProcess"); 324 base::Process process(handle); 325 int old_priority = process.GetPriority(); 326#if defined(OS_WIN) 327 EXPECT_TRUE(process.SetProcessBackgrounded(true)); 328 EXPECT_TRUE(process.IsProcessBackgrounded()); 329 EXPECT_TRUE(process.SetProcessBackgrounded(false)); 330 EXPECT_FALSE(process.IsProcessBackgrounded()); 331#else 332 process.SetProcessBackgrounded(true); 333 process.SetProcessBackgrounded(false); 334#endif 335 int new_priority = process.GetPriority(); 336 EXPECT_EQ(old_priority, new_priority); 337} 338 339// Same as SetProcessBackgrounded but to this very process. It uses 340// a different code path at least for Windows. 341TEST_F(ProcessUtilTest, SetProcessBackgroundedSelf) { 342 base::Process process(base::Process::Current().handle()); 343 int old_priority = process.GetPriority(); 344#if defined(OS_WIN) 345 EXPECT_TRUE(process.SetProcessBackgrounded(true)); 346 EXPECT_TRUE(process.IsProcessBackgrounded()); 347 EXPECT_TRUE(process.SetProcessBackgrounded(false)); 348 EXPECT_FALSE(process.IsProcessBackgrounded()); 349#else 350 process.SetProcessBackgrounded(true); 351 process.SetProcessBackgrounded(false); 352#endif 353 int new_priority = process.GetPriority(); 354 EXPECT_EQ(old_priority, new_priority); 355} 356 357#if defined(OS_WIN) 358// TODO(estade): if possible, port this test. 359TEST_F(ProcessUtilTest, GetAppOutput) { 360 // Let's create a decently long message. 361 std::string message; 362 for (int i = 0; i < 1025; i++) { // 1025 so it does not end on a kilo-byte 363 // boundary. 364 message += "Hello!"; 365 } 366 // cmd.exe's echo always adds a \r\n to its output. 367 std::string expected(message); 368 expected += "\r\n"; 369 370 FilePath cmd(L"cmd.exe"); 371 CommandLine cmd_line(cmd); 372 cmd_line.AppendArg("/c"); 373 cmd_line.AppendArg("echo " + message + ""); 374 std::string output; 375 ASSERT_TRUE(base::GetAppOutput(cmd_line, &output)); 376 EXPECT_EQ(expected, output); 377 378 // Let's make sure stderr is ignored. 379 CommandLine other_cmd_line(cmd); 380 other_cmd_line.AppendArg("/c"); 381 // http://msdn.microsoft.com/library/cc772622.aspx 382 cmd_line.AppendArg("echo " + message + " >&2"); 383 output.clear(); 384 ASSERT_TRUE(base::GetAppOutput(other_cmd_line, &output)); 385 EXPECT_EQ("", output); 386} 387 388// TODO(estade): if possible, port this test. 389TEST_F(ProcessUtilTest, LaunchAsUser) { 390 base::UserTokenHandle token; 391 ASSERT_TRUE(OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &token)); 392 base::LaunchOptions options; 393 options.as_user = token; 394 EXPECT_TRUE(base::LaunchProcess(MakeCmdLine("SimpleChildProcess"), options, 395 NULL)); 396} 397 398static const char kEventToTriggerHandleSwitch[] = "event-to-trigger-handle"; 399 400MULTIPROCESS_TEST_MAIN(TriggerEventChildProcess) { 401 std::string handle_value_string = 402 CommandLine::ForCurrentProcess()->GetSwitchValueASCII( 403 kEventToTriggerHandleSwitch); 404 CHECK(!handle_value_string.empty()); 405 406 uint64 handle_value_uint64; 407 CHECK(base::StringToUint64(handle_value_string, &handle_value_uint64)); 408 // Give ownership of the handle to |event|. 409 base::WaitableEvent event(reinterpret_cast<HANDLE>(handle_value_uint64)); 410 411 event.Signal(); 412 413 return 0; 414} 415 416TEST_F(ProcessUtilTest, InheritSpecifiedHandles) { 417 // Manually create the event, so that it can be inheritable. 418 SECURITY_ATTRIBUTES security_attributes = {}; 419 security_attributes.nLength = static_cast<DWORD>(sizeof(security_attributes)); 420 security_attributes.lpSecurityDescriptor = NULL; 421 security_attributes.bInheritHandle = true; 422 423 // Takes ownership of the event handle. 424 base::WaitableEvent event( 425 CreateEvent(&security_attributes, true, false, NULL)); 426 base::HandlesToInheritVector handles_to_inherit; 427 handles_to_inherit.push_back(event.handle()); 428 base::LaunchOptions options; 429 options.handles_to_inherit = &handles_to_inherit; 430 431 CommandLine cmd_line = MakeCmdLine("TriggerEventChildProcess"); 432 cmd_line.AppendSwitchASCII(kEventToTriggerHandleSwitch, 433 base::Uint64ToString(reinterpret_cast<uint64>(event.handle()))); 434 435 // This functionality actually requires Vista or later. Make sure that it 436 // fails properly on XP. 437 if (base::win::GetVersion() < base::win::VERSION_VISTA) { 438 EXPECT_FALSE(base::LaunchProcess(cmd_line, options, NULL)); 439 return; 440 } 441 442 // Launch the process and wait for it to trigger the event. 443 ASSERT_TRUE(base::LaunchProcess(cmd_line, options, NULL)); 444 EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout())); 445} 446#endif // defined(OS_WIN) 447 448#if defined(OS_POSIX) 449 450namespace { 451 452// Returns the maximum number of files that a process can have open. 453// Returns 0 on error. 454int GetMaxFilesOpenInProcess() { 455 struct rlimit rlim; 456 if (getrlimit(RLIMIT_NOFILE, &rlim) != 0) { 457 return 0; 458 } 459 460 // rlim_t is a uint64 - clip to maxint. We do this since FD #s are ints 461 // which are all 32 bits on the supported platforms. 462 rlim_t max_int = static_cast<rlim_t>(std::numeric_limits<int32>::max()); 463 if (rlim.rlim_cur > max_int) { 464 return max_int; 465 } 466 467 return rlim.rlim_cur; 468} 469 470const int kChildPipe = 20; // FD # for write end of pipe in child process. 471 472} // namespace 473 474MULTIPROCESS_TEST_MAIN(ProcessUtilsLeakFDChildProcess) { 475 // This child process counts the number of open FDs, it then writes that 476 // number out to a pipe connected to the parent. 477 int num_open_files = 0; 478 int write_pipe = kChildPipe; 479 int max_files = GetMaxFilesOpenInProcess(); 480 for (int i = STDERR_FILENO + 1; i < max_files; i++) { 481 if (i != kChildPipe) { 482 int fd; 483 if ((fd = HANDLE_EINTR(dup(i))) != -1) { 484 close(fd); 485 num_open_files += 1; 486 } 487 } 488 } 489 490 int written = HANDLE_EINTR(write(write_pipe, &num_open_files, 491 sizeof(num_open_files))); 492 DCHECK_EQ(static_cast<size_t>(written), sizeof(num_open_files)); 493 int ret = IGNORE_EINTR(close(write_pipe)); 494 DPCHECK(ret == 0); 495 496 return 0; 497} 498 499int ProcessUtilTest::CountOpenFDsInChild() { 500 int fds[2]; 501 if (pipe(fds) < 0) 502 NOTREACHED(); 503 504 base::FileHandleMappingVector fd_mapping_vec; 505 fd_mapping_vec.push_back(std::pair<int, int>(fds[1], kChildPipe)); 506 base::LaunchOptions options; 507 options.fds_to_remap = &fd_mapping_vec; 508 base::ProcessHandle handle = 509 SpawnChildWithOptions("ProcessUtilsLeakFDChildProcess", options); 510 CHECK(handle); 511 int ret = IGNORE_EINTR(close(fds[1])); 512 DPCHECK(ret == 0); 513 514 // Read number of open files in client process from pipe; 515 int num_open_files = -1; 516 ssize_t bytes_read = 517 HANDLE_EINTR(read(fds[0], &num_open_files, sizeof(num_open_files))); 518 CHECK_EQ(bytes_read, static_cast<ssize_t>(sizeof(num_open_files))); 519 520#if defined(THREAD_SANITIZER) 521 // Compiler-based ThreadSanitizer makes this test slow. 522 CHECK(base::WaitForSingleProcess(handle, base::TimeDelta::FromSeconds(3))); 523#else 524 CHECK(base::WaitForSingleProcess(handle, base::TimeDelta::FromSeconds(1))); 525#endif 526 base::CloseProcessHandle(handle); 527 ret = IGNORE_EINTR(close(fds[0])); 528 DPCHECK(ret == 0); 529 530 return num_open_files; 531} 532 533#if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER) 534// ProcessUtilTest.FDRemapping is flaky when ran under xvfb-run on Precise. 535// The problem is 100% reproducible with both ASan and TSan. 536// See http://crbug.com/136720. 537#define MAYBE_FDRemapping DISABLED_FDRemapping 538#else 539#define MAYBE_FDRemapping FDRemapping 540#endif 541TEST_F(ProcessUtilTest, MAYBE_FDRemapping) { 542 int fds_before = CountOpenFDsInChild(); 543 544 // open some dummy fds to make sure they don't propagate over to the 545 // child process. 546 int dev_null = open("/dev/null", O_RDONLY); 547 int sockets[2]; 548 socketpair(AF_UNIX, SOCK_STREAM, 0, sockets); 549 550 int fds_after = CountOpenFDsInChild(); 551 552 ASSERT_EQ(fds_after, fds_before); 553 554 int ret; 555 ret = IGNORE_EINTR(close(sockets[0])); 556 DPCHECK(ret == 0); 557 ret = IGNORE_EINTR(close(sockets[1])); 558 DPCHECK(ret == 0); 559 ret = IGNORE_EINTR(close(dev_null)); 560 DPCHECK(ret == 0); 561} 562 563namespace { 564 565std::string TestLaunchProcess(const std::vector<std::string>& args, 566 const base::EnvironmentMap& env_changes, 567 const bool clear_environ, 568 const int clone_flags) { 569 base::FileHandleMappingVector fds_to_remap; 570 571 int fds[2]; 572 PCHECK(pipe(fds) == 0); 573 574 fds_to_remap.push_back(std::make_pair(fds[1], 1)); 575 base::LaunchOptions options; 576 options.wait = true; 577 options.environ = env_changes; 578 options.clear_environ = clear_environ; 579 options.fds_to_remap = &fds_to_remap; 580#if defined(OS_LINUX) 581 options.clone_flags = clone_flags; 582#else 583 CHECK_EQ(0, clone_flags); 584#endif // OS_LINUX 585 EXPECT_TRUE(base::LaunchProcess(args, options, NULL)); 586 PCHECK(IGNORE_EINTR(close(fds[1])) == 0); 587 588 char buf[512]; 589 const ssize_t n = HANDLE_EINTR(read(fds[0], buf, sizeof(buf))); 590 591 PCHECK(IGNORE_EINTR(close(fds[0])) == 0); 592 593 return std::string(buf, n); 594} 595 596const char kLargeString[] = 597 "0123456789012345678901234567890123456789012345678901234567890123456789" 598 "0123456789012345678901234567890123456789012345678901234567890123456789" 599 "0123456789012345678901234567890123456789012345678901234567890123456789" 600 "0123456789012345678901234567890123456789012345678901234567890123456789" 601 "0123456789012345678901234567890123456789012345678901234567890123456789" 602 "0123456789012345678901234567890123456789012345678901234567890123456789" 603 "0123456789012345678901234567890123456789012345678901234567890123456789"; 604 605} // namespace 606 607TEST_F(ProcessUtilTest, LaunchProcess) { 608 base::EnvironmentMap env_changes; 609 std::vector<std::string> echo_base_test; 610 echo_base_test.push_back(kPosixShell); 611 echo_base_test.push_back("-c"); 612 echo_base_test.push_back("echo $BASE_TEST"); 613 614 std::vector<std::string> print_env; 615 print_env.push_back("/usr/bin/env"); 616 const int no_clone_flags = 0; 617 const bool no_clear_environ = false; 618 619 const char kBaseTest[] = "BASE_TEST"; 620 621 env_changes[kBaseTest] = "bar"; 622 EXPECT_EQ("bar\n", 623 TestLaunchProcess( 624 echo_base_test, env_changes, no_clear_environ, no_clone_flags)); 625 env_changes.clear(); 626 627 EXPECT_EQ(0, setenv(kBaseTest, "testing", 1 /* override */)); 628 EXPECT_EQ("testing\n", 629 TestLaunchProcess( 630 echo_base_test, env_changes, no_clear_environ, no_clone_flags)); 631 632 env_changes[kBaseTest] = std::string(); 633 EXPECT_EQ("\n", 634 TestLaunchProcess( 635 echo_base_test, env_changes, no_clear_environ, no_clone_flags)); 636 637 env_changes[kBaseTest] = "foo"; 638 EXPECT_EQ("foo\n", 639 TestLaunchProcess( 640 echo_base_test, env_changes, no_clear_environ, no_clone_flags)); 641 642 env_changes.clear(); 643 EXPECT_EQ(0, setenv(kBaseTest, kLargeString, 1 /* override */)); 644 EXPECT_EQ(std::string(kLargeString) + "\n", 645 TestLaunchProcess( 646 echo_base_test, env_changes, no_clear_environ, no_clone_flags)); 647 648 env_changes[kBaseTest] = "wibble"; 649 EXPECT_EQ("wibble\n", 650 TestLaunchProcess( 651 echo_base_test, env_changes, no_clear_environ, no_clone_flags)); 652 653#if defined(OS_LINUX) 654 // Test a non-trival value for clone_flags. 655 // Don't test on Valgrind as it has limited support for clone(). 656 if (!RunningOnValgrind()) { 657 EXPECT_EQ( 658 "wibble\n", 659 TestLaunchProcess( 660 echo_base_test, env_changes, no_clear_environ, CLONE_FS | SIGCHLD)); 661 } 662 663 EXPECT_EQ( 664 "BASE_TEST=wibble\n", 665 TestLaunchProcess( 666 print_env, env_changes, true /* clear_environ */, no_clone_flags)); 667 env_changes.clear(); 668 EXPECT_EQ( 669 "", 670 TestLaunchProcess( 671 print_env, env_changes, true /* clear_environ */, no_clone_flags)); 672#endif 673} 674 675TEST_F(ProcessUtilTest, GetAppOutput) { 676 std::string output; 677 678#if defined(OS_ANDROID) 679 std::vector<std::string> argv; 680 argv.push_back("sh"); // Instead of /bin/sh, force path search to find it. 681 argv.push_back("-c"); 682 683 argv.push_back("exit 0"); 684 EXPECT_TRUE(base::GetAppOutput(CommandLine(argv), &output)); 685 EXPECT_STREQ("", output.c_str()); 686 687 argv[2] = "exit 1"; 688 EXPECT_FALSE(base::GetAppOutput(CommandLine(argv), &output)); 689 EXPECT_STREQ("", output.c_str()); 690 691 argv[2] = "echo foobar42"; 692 EXPECT_TRUE(base::GetAppOutput(CommandLine(argv), &output)); 693 EXPECT_STREQ("foobar42\n", output.c_str()); 694#else 695 EXPECT_TRUE(base::GetAppOutput(CommandLine(FilePath("true")), &output)); 696 EXPECT_STREQ("", output.c_str()); 697 698 EXPECT_FALSE(base::GetAppOutput(CommandLine(FilePath("false")), &output)); 699 700 std::vector<std::string> argv; 701 argv.push_back("/bin/echo"); 702 argv.push_back("-n"); 703 argv.push_back("foobar42"); 704 EXPECT_TRUE(base::GetAppOutput(CommandLine(argv), &output)); 705 EXPECT_STREQ("foobar42", output.c_str()); 706#endif // defined(OS_ANDROID) 707} 708 709// Flakes on Android, crbug.com/375840 710#if defined(OS_ANDROID) 711#define MAYBE_GetAppOutputRestricted DISABLED_GetAppOutputRestricted 712#else 713#define MAYBE_GetAppOutputRestricted GetAppOutputRestricted 714#endif 715TEST_F(ProcessUtilTest, MAYBE_GetAppOutputRestricted) { 716 // Unfortunately, since we can't rely on the path, we need to know where 717 // everything is. So let's use /bin/sh, which is on every POSIX system, and 718 // its built-ins. 719 std::vector<std::string> argv; 720 argv.push_back(std::string(kShellPath)); // argv[0] 721 argv.push_back("-c"); // argv[1] 722 723 // On success, should set |output|. We use |/bin/sh -c 'exit 0'| instead of 724 // |true| since the location of the latter may be |/bin| or |/usr/bin| (and we 725 // need absolute paths). 726 argv.push_back("exit 0"); // argv[2]; equivalent to "true" 727 std::string output = "abc"; 728 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 100)); 729 EXPECT_STREQ("", output.c_str()); 730 731 argv[2] = "exit 1"; // equivalent to "false" 732 output = "before"; 733 EXPECT_FALSE(base::GetAppOutputRestricted(CommandLine(argv), 734 &output, 100)); 735 EXPECT_STREQ("", output.c_str()); 736 737 // Amount of output exactly equal to space allowed. 738 argv[2] = "echo 123456789"; // (the sh built-in doesn't take "-n") 739 output.clear(); 740 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 10)); 741 EXPECT_STREQ("123456789\n", output.c_str()); 742 743 // Amount of output greater than space allowed. 744 output.clear(); 745 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 5)); 746 EXPECT_STREQ("12345", output.c_str()); 747 748 // Amount of output less than space allowed. 749 output.clear(); 750 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 15)); 751 EXPECT_STREQ("123456789\n", output.c_str()); 752 753 // Zero space allowed. 754 output = "abc"; 755 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 0)); 756 EXPECT_STREQ("", output.c_str()); 757} 758 759#if !defined(OS_MACOSX) && !defined(OS_OPENBSD) 760// TODO(benwells): GetAppOutputRestricted should terminate applications 761// with SIGPIPE when we have enough output. http://crbug.com/88502 762TEST_F(ProcessUtilTest, GetAppOutputRestrictedSIGPIPE) { 763 std::vector<std::string> argv; 764 std::string output; 765 766 argv.push_back(std::string(kShellPath)); // argv[0] 767 argv.push_back("-c"); 768#if defined(OS_ANDROID) 769 argv.push_back("while echo 12345678901234567890; do :; done"); 770 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 10)); 771 EXPECT_STREQ("1234567890", output.c_str()); 772#else 773 argv.push_back("yes"); 774 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 10)); 775 EXPECT_STREQ("y\ny\ny\ny\ny\n", output.c_str()); 776#endif 777} 778#endif 779 780#if defined(ADDRESS_SANITIZER) && defined(OS_MACOSX) && \ 781 defined(ARCH_CPU_64_BITS) 782// Times out under AddressSanitizer on 64-bit OS X, see 783// http://crbug.com/298197. 784#define MAYBE_GetAppOutputRestrictedNoZombies \ 785 DISABLED_GetAppOutputRestrictedNoZombies 786#else 787#define MAYBE_GetAppOutputRestrictedNoZombies GetAppOutputRestrictedNoZombies 788#endif 789TEST_F(ProcessUtilTest, MAYBE_GetAppOutputRestrictedNoZombies) { 790 std::vector<std::string> argv; 791 792 argv.push_back(std::string(kShellPath)); // argv[0] 793 argv.push_back("-c"); // argv[1] 794 argv.push_back("echo 123456789012345678901234567890"); // argv[2] 795 796 // Run |GetAppOutputRestricted()| 300 (> default per-user processes on Mac OS 797 // 10.5) times with an output buffer big enough to capture all output. 798 for (int i = 0; i < 300; i++) { 799 std::string output; 800 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 100)); 801 EXPECT_STREQ("123456789012345678901234567890\n", output.c_str()); 802 } 803 804 // Ditto, but with an output buffer too small to capture all output. 805 for (int i = 0; i < 300; i++) { 806 std::string output; 807 EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 10)); 808 EXPECT_STREQ("1234567890", output.c_str()); 809 } 810} 811 812TEST_F(ProcessUtilTest, GetAppOutputWithExitCode) { 813 // Test getting output from a successful application. 814 std::vector<std::string> argv; 815 std::string output; 816 int exit_code; 817 argv.push_back(std::string(kShellPath)); // argv[0] 818 argv.push_back("-c"); // argv[1] 819 argv.push_back("echo foo"); // argv[2]; 820 EXPECT_TRUE(base::GetAppOutputWithExitCode(CommandLine(argv), &output, 821 &exit_code)); 822 EXPECT_STREQ("foo\n", output.c_str()); 823 EXPECT_EQ(exit_code, 0); 824 825 // Test getting output from an application which fails with a specific exit 826 // code. 827 output.clear(); 828 argv[2] = "echo foo; exit 2"; 829 EXPECT_TRUE(base::GetAppOutputWithExitCode(CommandLine(argv), &output, 830 &exit_code)); 831 EXPECT_STREQ("foo\n", output.c_str()); 832 EXPECT_EQ(exit_code, 2); 833} 834 835TEST_F(ProcessUtilTest, GetParentProcessId) { 836 base::ProcessId ppid = base::GetParentProcessId(base::GetCurrentProcId()); 837 EXPECT_EQ(ppid, getppid()); 838} 839 840// TODO(port): port those unit tests. 841bool IsProcessDead(base::ProcessHandle child) { 842 // waitpid() will actually reap the process which is exactly NOT what we 843 // want to test for. The good thing is that if it can't find the process 844 // we'll get a nice value for errno which we can test for. 845 const pid_t result = HANDLE_EINTR(waitpid(child, NULL, WNOHANG)); 846 return result == -1 && errno == ECHILD; 847} 848 849TEST_F(ProcessUtilTest, DelayedTermination) { 850 base::ProcessHandle child_process = SpawnChild("process_util_test_never_die"); 851 ASSERT_TRUE(child_process); 852 base::EnsureProcessTerminated(child_process); 853 base::WaitForSingleProcess(child_process, base::TimeDelta::FromSeconds(5)); 854 855 // Check that process was really killed. 856 EXPECT_TRUE(IsProcessDead(child_process)); 857 base::CloseProcessHandle(child_process); 858} 859 860MULTIPROCESS_TEST_MAIN(process_util_test_never_die) { 861 while (1) { 862 sleep(500); 863 } 864 return 0; 865} 866 867TEST_F(ProcessUtilTest, ImmediateTermination) { 868 base::ProcessHandle child_process = 869 SpawnChild("process_util_test_die_immediately"); 870 ASSERT_TRUE(child_process); 871 // Give it time to die. 872 sleep(2); 873 base::EnsureProcessTerminated(child_process); 874 875 // Check that process was really killed. 876 EXPECT_TRUE(IsProcessDead(child_process)); 877 base::CloseProcessHandle(child_process); 878} 879 880MULTIPROCESS_TEST_MAIN(process_util_test_die_immediately) { 881 return 0; 882} 883 884#endif // defined(OS_POSIX) 885