base/process/process_posix.cc

   1 // Copyright 2011 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 #include "base/process/process.h"
   6
   7 #include <sys/resource.h>
   8 #include <sys/wait.h>
   9
  10 #include "base/files/scoped_file.h"
  11 #include "base/logging.h"
  12 #include "base/posix/eintr_wrapper.h"
  13 #include "base/process/kill.h"
  14 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
  15
  16 #if defined(OS_MACOSX)
  17 #include <sys/event.h>
  18 #endif
  19
  20 namespace {
  21
  22 #if !defined(OS_NACL_NONSFI)
  23
  24 bool WaitpidWithTimeout(base::ProcessHandle handle,
  25                         int* status,
  26                         base::TimeDelta wait) {
  27   // This POSIX version of this function only guarantees that we wait no less
  28   // than |wait| for the process to exit.  The child process may
  29   // exit sometime before the timeout has ended but we may still block for up
  30   // to 256 milliseconds after the fact.
  31   //
  32   // waitpid() has no direct support on POSIX for specifying a timeout, you can
  33   // either ask it to block indefinitely or return immediately (WNOHANG).
  34   // When a child process terminates a SIGCHLD signal is sent to the parent.
  35   // Catching this signal would involve installing a signal handler which may
  36   // affect other parts of the application and would be difficult to debug.
  37   //
  38   // Our strategy is to call waitpid() once up front to check if the process
  39   // has already exited, otherwise to loop for |wait|, sleeping for
  40   // at most 256 milliseconds each time using usleep() and then calling
  41   // waitpid().  The amount of time we sleep starts out at 1 milliseconds, and
  42   // we double it every 4 sleep cycles.
  43   //
  44   // usleep() is speced to exit if a signal is received for which a handler
  45   // has been installed.  This means that when a SIGCHLD is sent, it will exit
  46   // depending on behavior external to this function.
  47   //
  48   // This function is used primarily for unit tests, if we want to use it in
  49   // the application itself it would probably be best to examine other routes.
  50
  51   if (wait == base::TimeDelta::Max()) {
  52     return HANDLE_EINTR(waitpid(handle, status, 0)) > 0;
  53   }
  54
  55   pid_t ret_pid = HANDLE_EINTR(waitpid(handle, status, WNOHANG));
  56   static const int64 kMaxSleepInMicroseconds = 1 << 18;  // ~256 milliseconds.
  57   int64 max_sleep_time_usecs = 1 << 10;  // ~1 milliseconds.
  58   int64 double_sleep_time = 0;
  59
  60   // If the process hasn't exited yet, then sleep and try again.
  61   base::TimeTicks wakeup_time = base::TimeTicks::Now() + wait;
  62   while (ret_pid == 0) {
  63     base::TimeTicks now = base::TimeTicks::Now();
  64     if (now > wakeup_time)
  65       break;
  66     // Guaranteed to be non-negative!
  67     int64 sleep_time_usecs = (wakeup_time - now).InMicroseconds();
  68     // Sleep for a bit while we wait for the process to finish.
  69     if (sleep_time_usecs > max_sleep_time_usecs)
  70       sleep_time_usecs = max_sleep_time_usecs;
  71
  72     // usleep() will return 0 and set errno to EINTR on receipt of a signal
  73     // such as SIGCHLD.
  74     usleep(sleep_time_usecs);
  75     ret_pid = HANDLE_EINTR(waitpid(handle, status, WNOHANG));
  76
  77     if ((max_sleep_time_usecs < kMaxSleepInMicroseconds) &&
  78         (double_sleep_time++ % 4 == 0)) {
  79       max_sleep_time_usecs *= 2;
  80     }
  81   }
  82
  83   return ret_pid > 0;
  84 }
  85
  86 #if defined(OS_MACOSX)
  87 // Using kqueue on Mac so that we can wait on non-child processes.
  88 // We can't use kqueues on child processes because we need to reap
  89 // our own children using wait.
  90 static bool WaitForSingleNonChildProcess(base::ProcessHandle handle,
  91                                          base::TimeDelta wait) {
  92   DCHECK_GT(handle, 0);
  93   DCHECK_GT(wait, base::TimeDelta());
  94
  95   base::ScopedFD kq(kqueue());
  96   if (!kq.is_valid()) {
  97     DPLOG(ERROR) << "kqueue";
  98     return false;
  99   }
 100
 101   struct kevent change = {0};
 102   EV_SET(&change, handle, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, NULL);
 103   int result = HANDLE_EINTR(kevent(kq.get(), &change, 1, NULL, 0, NULL));
 104   if (result == -1) {
 105     if (errno == ESRCH) {
 106       // If the process wasn't found, it must be dead.
 107       return true;
 108     }
 109
 110     DPLOG(ERROR) << "kevent (setup " << handle << ")";
 111     return false;
 112   }
 113
 114   // Keep track of the elapsed time to be able to restart kevent if it's
 115   // interrupted.
 116   bool wait_forever = (wait == base::TimeDelta::Max());
 117   base::TimeDelta remaining_delta;
 118   base::TimeTicks deadline;
 119   if (!wait_forever) {
 120     remaining_delta = wait;
 121     deadline = base::TimeTicks::Now() + remaining_delta;
 122   }
 123
 124   result = -1;
 125   struct kevent event = {0};
 126
 127   while (wait_forever || remaining_delta > base::TimeDelta()) {
 128     struct timespec remaining_timespec;
 129     struct timespec* remaining_timespec_ptr;
 130     if (wait_forever) {
 131       remaining_timespec_ptr = NULL;
 132     } else {
 133       remaining_timespec = remaining_delta.ToTimeSpec();
 134       remaining_timespec_ptr = &remaining_timespec;
 135     }
 136
 137     result = kevent(kq.get(), NULL, 0, &event, 1, remaining_timespec_ptr);
 138
 139     if (result == -1 && errno == EINTR) {
 140       if (!wait_forever) {
 141         remaining_delta = deadline - base::TimeTicks::Now();
 142       }
 143       result = 0;
 144     } else {
 145       break;
 146     }
 147   }
 148
 149   if (result < 0) {
 150     DPLOG(ERROR) << "kevent (wait " << handle << ")";
 151     return false;
 152   } else if (result > 1) {
 153     DLOG(ERROR) << "kevent (wait " << handle << "): unexpected result "
 154                 << result;
 155     return false;
 156   } else if (result == 0) {
 157     // Timed out.
 158     return false;
 159   }
 160
 161   DCHECK_EQ(result, 1);
 162
 163   if (event.filter != EVFILT_PROC ||
 164       (event.fflags & NOTE_EXIT) == 0 ||
 165       event.ident != static_cast<uintptr_t>(handle)) {
 166     DLOG(ERROR) << "kevent (wait " << handle
 167                 << "): unexpected event: filter=" << event.filter
 168                 << ", fflags=" << event.fflags
 169                 << ", ident=" << event.ident;
 170     return false;
 171   }
 172
 173   return true;
 174 }
 175 #endif  // OS_MACOSX
 176
 177 bool WaitForExitWithTimeoutImpl(base::ProcessHandle handle,
 178                                 int* exit_code,
 179                                 base::TimeDelta timeout) {
 180   base::ProcessHandle parent_pid = base::GetParentProcessId(handle);
 181   base::ProcessHandle our_pid = base::GetCurrentProcessHandle();
 182   if (parent_pid != our_pid) {
 183 #if defined(OS_MACOSX)
 184     // On Mac we can wait on non child processes.
 185     return WaitForSingleNonChildProcess(handle, timeout);
 186 #else
 187     // Currently on Linux we can't handle non child processes.
 188     NOTIMPLEMENTED();
 189 #endif  // OS_MACOSX
 190   }
 191
 192   int status;
 193   if (!WaitpidWithTimeout(handle, &status, timeout))
 194     return false;
 195   if (WIFSIGNALED(status)) {
 196     if (exit_code)
 197       *exit_code = -1;
 198     return true;
 199   }
 200   if (WIFEXITED(status)) {
 201     if (exit_code)
 202       *exit_code = WEXITSTATUS(status);
 203     return true;
 204   }
 205   return false;
 206 }
 207 #endif  // !defined(OS_NACL_NONSFI)
 208
 209 }  // namespace
 210
 211 namespace base {
 212
 213 Process::Process(ProcessHandle handle) : process_(handle) {
 214 }
 215
 216 Process::~Process() {
 217 }
 218
 219 Process::Process(RValue other)
 220     : process_(other.object->process_) {
 221   other.object->Close();
 222 }
 223
 224 Process& Process::operator=(RValue other) {
 225   if (this != other.object) {
 226     process_ = other.object->process_;
 227     other.object->Close();
 228   }
 229   return *this;
 230 }
 231
 232 // static
 233 Process Process::Current() {
 234   return Process(GetCurrentProcessHandle());
 235 }
 236
 237 // static
 238 Process Process::Open(ProcessId pid) {
 239   if (pid == GetCurrentProcId())
 240     return Current();
 241
 242   // On POSIX process handles are the same as PIDs.
 243   return Process(pid);
 244 }
 245
 246 // static
 247 Process Process::OpenWithExtraPrivileges(ProcessId pid) {
 248   // On POSIX there are no privileges to set.
 249   return Open(pid);
 250 }
 251
 252 // static
 253 Process Process::DeprecatedGetProcessFromHandle(ProcessHandle handle) {
 254   DCHECK_NE(handle, GetCurrentProcessHandle());
 255   return Process(handle);
 256 }
 257
 258 #if !defined(OS_LINUX) && !defined(OS_MACOSX)
 259 // static
 260 bool Process::CanBackgroundProcesses() {
 261   return false;
 262 }
 263 #endif  // !defined(OS_LINUX) && !defined(OS_MACOSX)
 264
 265 bool Process::IsValid() const {
 266   return process_ != kNullProcessHandle;
 267 }
 268
 269 ProcessHandle Process::Handle() const {
 270   return process_;
 271 }
 272
 273 Process Process::Duplicate() const {
 274   if (is_current())
 275     return Current();
 276
 277   return Process(process_);
 278 }
 279
 280 ProcessId Process::Pid() const {
 281   DCHECK(IsValid());
 282   return GetProcId(process_);
 283 }
 284
 285 bool Process::is_current() const {
 286   return process_ == GetCurrentProcessHandle();
 287 }
 288
 289 void Process::Close() {
 290   process_ = kNullProcessHandle;
 291   // if the process wasn't terminated (so we waited) or the state
 292   // wasn't already collected w/ a wait from process_utils, we're gonna
 293   // end up w/ a zombie when it does finally exit.
 294 }
 295
 296 #if !defined(OS_NACL_NONSFI)
 297 bool Process::Terminate(int exit_code, bool wait) const {
 298   // exit_code isn't supportable.
 299   DCHECK(IsValid());
 300   CHECK_GT(process_, 0);
 301
 302   bool result = kill(process_, SIGTERM) == 0;
 303   if (result && wait) {
 304     int tries = 60;
 305
 306     if (RunningOnValgrind()) {
 307       // Wait for some extra time when running under Valgrind since the child
 308       // processes may take some time doing leak checking.
 309       tries *= 2;
 310     }
 311
 312     unsigned sleep_ms = 4;
 313
 314     // The process may not end immediately due to pending I/O
 315     bool exited = false;
 316     while (tries-- > 0) {
 317       pid_t pid = HANDLE_EINTR(waitpid(process_, NULL, WNOHANG));
 318       if (pid == process_) {
 319         exited = true;
 320         break;
 321       }
 322       if (pid == -1) {
 323         if (errno == ECHILD) {
 324           // The wait may fail with ECHILD if another process also waited for
 325           // the same pid, causing the process state to get cleaned up.
 326           exited = true;
 327           break;
 328         }
 329         DPLOG(ERROR) << "Error waiting for process " << process_;
 330       }
 331
 332       usleep(sleep_ms * 1000);
 333       const unsigned kMaxSleepMs = 1000;
 334       if (sleep_ms < kMaxSleepMs)
 335         sleep_ms *= 2;
 336     }
 337
 338     // If we're waiting and the child hasn't died by now, force it
 339     // with a SIGKILL.
 340     if (!exited)
 341       result = kill(process_, SIGKILL) == 0;
 342   }
 343
 344   if (!result)
 345     DPLOG(ERROR) << "Unable to terminate process " << process_;
 346
 347   return result;
 348 }
 349 #endif  // !defined(OS_NACL_NONSFI)
 350
 351 bool Process::WaitForExit(int* exit_code) {
 352   return WaitForExitWithTimeout(TimeDelta::Max(), exit_code);
 353 }
 354
 355 bool Process::WaitForExitWithTimeout(TimeDelta timeout, int* exit_code) {
 356   return WaitForExitWithTimeoutImpl(Handle(), exit_code, timeout);
 357 }
 358
 359 #if !defined(OS_LINUX) && !defined(OS_MACOSX)
 360 bool Process::IsProcessBackgrounded() const {
 361   // See SetProcessBackgrounded().
 362   DCHECK(IsValid());
 363   return false;
 364 }
 365
 366 bool Process::SetProcessBackgrounded(bool value) {
 367   // Not implemented for POSIX systems other than Mac and Linux. With POSIX, if
 368   // we were to lower the process priority we wouldn't be able to raise it back
 369   // to its initial priority.
 370   NOTIMPLEMENTED();
 371   return false;
 372 }
 373 #endif  // !defined(OS_LINUX) && !defined(OS_MACOSX)
 374
 375 int Process::GetPriority() const {
 376   DCHECK(IsValid());
 377   return getpriority(PRIO_PROCESS, process_);
 378 }
 379
 380 }  // namespace base