src/base/process/process_util_unittest.cc

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