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