base/process/kill_posix.cc

   1 // Copyright (c) 2013 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/kill.h"
   6
   7 #include <signal.h>
   8 #include <sys/types.h>
   9 #include <sys/wait.h>
  10 #include <unistd.h>
  11
  12 #include "base/files/file_util.h"
  13 #include "base/files/scoped_file.h"
  14 #include "base/logging.h"
  15 #include "base/posix/eintr_wrapper.h"
  16 #include "base/process/process_iterator.h"
  17 #include "base/synchronization/waitable_event.h"
  18 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
  19 #include "base/threading/platform_thread.h"
  20
  21 namespace base {
  22
  23 namespace {
  24
  25 bool WaitpidWithTimeout(ProcessHandle handle,
  26                         int* status,
  27                         base::TimeDelta wait) {
  28   // This POSIX version of this function only guarantees that we wait no less
  29   // than |wait| for the process to exit.  The child process may
  30   // exit sometime before the timeout has ended but we may still block for up
  31   // to 256 milliseconds after the fact.
  32   //
  33   // waitpid() has no direct support on POSIX for specifying a timeout, you can
  34   // either ask it to block indefinitely or return immediately (WNOHANG).
  35   // When a child process terminates a SIGCHLD signal is sent to the parent.
  36   // Catching this signal would involve installing a signal handler which may
  37   // affect other parts of the application and would be difficult to debug.
  38   //
  39   // Our strategy is to call waitpid() once up front to check if the process
  40   // has already exited, otherwise to loop for |wait|, sleeping for
  41   // at most 256 milliseconds each time using usleep() and then calling
  42   // waitpid().  The amount of time we sleep starts out at 1 milliseconds, and
  43   // we double it every 4 sleep cycles.
  44   //
  45   // usleep() is speced to exit if a signal is received for which a handler
  46   // has been installed.  This means that when a SIGCHLD is sent, it will exit
  47   // depending on behavior external to this function.
  48   //
  49   // This function is used primarily for unit tests, if we want to use it in
  50   // the application itself it would probably be best to examine other routes.
  51
  52   if (wait.InMilliseconds() == base::kNoTimeout) {
  53     return HANDLE_EINTR(waitpid(handle, status, 0)) > 0;
  54   }
  55
  56   pid_t ret_pid = HANDLE_EINTR(waitpid(handle, status, WNOHANG));
  57   static const int64 kMaxSleepInMicroseconds = 1 << 18;  // ~256 milliseconds.
  58   int64 max_sleep_time_usecs = 1 << 10;  // ~1 milliseconds.
  59   int64 double_sleep_time = 0;
  60
  61   // If the process hasn't exited yet, then sleep and try again.
  62   TimeTicks wakeup_time = TimeTicks::Now() + wait;
  63   while (ret_pid == 0) {
  64     TimeTicks now = TimeTicks::Now();
  65     if (now > wakeup_time)
  66       break;
  67     // Guaranteed to be non-negative!
  68     int64 sleep_time_usecs = (wakeup_time - now).InMicroseconds();
  69     // Sleep for a bit while we wait for the process to finish.
  70     if (sleep_time_usecs > max_sleep_time_usecs)
  71       sleep_time_usecs = max_sleep_time_usecs;
  72
  73     // usleep() will return 0 and set errno to EINTR on receipt of a signal
  74     // such as SIGCHLD.
  75     usleep(sleep_time_usecs);
  76     ret_pid = HANDLE_EINTR(waitpid(handle, status, WNOHANG));
  77
  78     if ((max_sleep_time_usecs < kMaxSleepInMicroseconds) &&
  79         (double_sleep_time++ % 4 == 0)) {
  80       max_sleep_time_usecs *= 2;
  81     }
  82   }
  83
  84   return ret_pid > 0;
  85 }
  86
  87 TerminationStatus GetTerminationStatusImpl(ProcessHandle handle,
  88                                            bool can_block,
  89                                            int* exit_code) {
  90   int status = 0;
  91   const pid_t result = HANDLE_EINTR(waitpid(handle, &status,
  92                                             can_block ? 0 : WNOHANG));
  93   if (result == -1) {
  94     DPLOG(ERROR) << "waitpid(" << handle << ")";
  95     if (exit_code)
  96       *exit_code = 0;
  97     return TERMINATION_STATUS_NORMAL_TERMINATION;
  98   } else if (result == 0) {
  99     // the child hasn't exited yet.
 100     if (exit_code)
 101       *exit_code = 0;
 102     return TERMINATION_STATUS_STILL_RUNNING;
 103   }
 104
 105   if (exit_code)
 106     *exit_code = status;
 107
 108   if (WIFSIGNALED(status)) {
 109     switch (WTERMSIG(status)) {
 110       case SIGABRT:
 111       case SIGBUS:
 112       case SIGFPE:
 113       case SIGILL:
 114       case SIGSEGV:
 115         return TERMINATION_STATUS_PROCESS_CRASHED;
 116       case SIGINT:
 117       case SIGKILL:
 118       case SIGTERM:
 119         return TERMINATION_STATUS_PROCESS_WAS_KILLED;
 120       default:
 121         break;
 122     }
 123   }
 124
 125   if (WIFEXITED(status) && WEXITSTATUS(status) != 0)
 126     return TERMINATION_STATUS_ABNORMAL_TERMINATION;
 127
 128   return TERMINATION_STATUS_NORMAL_TERMINATION;
 129 }
 130
 131 }  // namespace
 132
 133 // Attempts to kill the process identified by the given process
 134 // entry structure.  Ignores specified exit_code; posix can't force that.
 135 // Returns true if this is successful, false otherwise.
 136 bool KillProcess(ProcessHandle process_id, int exit_code, bool wait) {
 137   DCHECK_GT(process_id, 1) << " tried to kill invalid process_id";
 138   if (process_id <= 1)
 139     return false;
 140   bool result = kill(process_id, SIGTERM) == 0;
 141   if (result && wait) {
 142     int tries = 60;
 143
 144     if (RunningOnValgrind()) {
 145       // Wait for some extra time when running under Valgrind since the child
 146       // processes may take some time doing leak checking.
 147       tries *= 2;
 148     }
 149
 150     unsigned sleep_ms = 4;
 151
 152     // The process may not end immediately due to pending I/O
 153     bool exited = false;
 154     while (tries-- > 0) {
 155       pid_t pid = HANDLE_EINTR(waitpid(process_id, NULL, WNOHANG));
 156       if (pid == process_id) {
 157         exited = true;
 158         break;
 159       }
 160       if (pid == -1) {
 161         if (errno == ECHILD) {
 162           // The wait may fail with ECHILD if another process also waited for
 163           // the same pid, causing the process state to get cleaned up.
 164           exited = true;
 165           break;
 166         }
 167         DPLOG(ERROR) << "Error waiting for process " << process_id;
 168       }
 169
 170       usleep(sleep_ms * 1000);
 171       const unsigned kMaxSleepMs = 1000;
 172       if (sleep_ms < kMaxSleepMs)
 173         sleep_ms *= 2;
 174     }
 175
 176     // If we're waiting and the child hasn't died by now, force it
 177     // with a SIGKILL.
 178     if (!exited)
 179       result = kill(process_id, SIGKILL) == 0;
 180   }
 181
 182   if (!result)
 183     DPLOG(ERROR) << "Unable to terminate process " << process_id;
 184
 185   return result;
 186 }
 187
 188 bool KillProcessGroup(ProcessHandle process_group_id) {
 189   bool result = kill(-1 * process_group_id, SIGKILL) == 0;
 190   if (!result)
 191     DPLOG(ERROR) << "Unable to terminate process group " << process_group_id;
 192   return result;
 193 }
 194
 195 TerminationStatus GetTerminationStatus(ProcessHandle handle, int* exit_code) {
 196   return GetTerminationStatusImpl(handle, false /* can_block */, exit_code);
 197 }
 198
 199 TerminationStatus GetKnownDeadTerminationStatus(ProcessHandle handle,
 200                                                 int* exit_code) {
 201   bool result = kill(handle, SIGKILL) == 0;
 202
 203   if (!result)
 204     DPLOG(ERROR) << "Unable to terminate process " << handle;
 205
 206   return GetTerminationStatusImpl(handle, true /* can_block */, exit_code);
 207 }
 208
 209 bool WaitForExitCode(ProcessHandle handle, int* exit_code) {
 210   int status;
 211   if (HANDLE_EINTR(waitpid(handle, &status, 0)) == -1) {
 212     NOTREACHED();
 213     return false;
 214   }
 215
 216   if (WIFEXITED(status)) {
 217     *exit_code = WEXITSTATUS(status);
 218     return true;
 219   }
 220
 221   // If it didn't exit cleanly, it must have been signaled.
 222   DCHECK(WIFSIGNALED(status));
 223   return false;
 224 }
 225
 226 bool WaitForExitCodeWithTimeout(ProcessHandle handle,
 227                                 int* exit_code,
 228                                 base::TimeDelta timeout) {
 229   int status;
 230   if (!WaitpidWithTimeout(handle, &status, timeout))
 231     return false;
 232   if (WIFSIGNALED(status)) {
 233     *exit_code = -1;
 234     return true;
 235   }
 236   if (WIFEXITED(status)) {
 237     *exit_code = WEXITSTATUS(status);
 238     return true;
 239   }
 240   return false;
 241 }
 242
 243 bool WaitForProcessesToExit(const FilePath::StringType& executable_name,
 244                             base::TimeDelta wait,
 245                             const ProcessFilter* filter) {
 246   bool result = false;
 247
 248   // TODO(port): This is inefficient, but works if there are multiple procs.
 249   // TODO(port): use waitpid to avoid leaving zombies around
 250
 251   base::TimeTicks end_time = base::TimeTicks::Now() + wait;
 252   do {
 253     NamedProcessIterator iter(executable_name, filter);
 254     if (!iter.NextProcessEntry()) {
 255       result = true;
 256       break;
 257     }
 258     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
 259   } while ((end_time - base::TimeTicks::Now()) > base::TimeDelta());
 260
 261   return result;
 262 }
 263
 264 #if defined(OS_MACOSX)
 265 // Using kqueue on Mac so that we can wait on non-child processes.
 266 // We can't use kqueues on child processes because we need to reap
 267 // our own children using wait.
 268 static bool WaitForSingleNonChildProcess(ProcessHandle handle,
 269                                          base::TimeDelta wait) {
 270   DCHECK_GT(handle, 0);
 271   DCHECK(wait.InMilliseconds() == base::kNoTimeout || wait > base::TimeDelta());
 272
 273   ScopedFD kq(kqueue());
 274   if (!kq.is_valid()) {
 275     DPLOG(ERROR) << "kqueue";
 276     return false;
 277   }
 278
 279   struct kevent change = {0};
 280   EV_SET(&change, handle, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, NULL);
 281   int result = HANDLE_EINTR(kevent(kq.get(), &change, 1, NULL, 0, NULL));
 282   if (result == -1) {
 283     if (errno == ESRCH) {
 284       // If the process wasn't found, it must be dead.
 285       return true;
 286     }
 287
 288     DPLOG(ERROR) << "kevent (setup " << handle << ")";
 289     return false;
 290   }
 291
 292   // Keep track of the elapsed time to be able to restart kevent if it's
 293   // interrupted.
 294   bool wait_forever = wait.InMilliseconds() == base::kNoTimeout;
 295   base::TimeDelta remaining_delta;
 296   base::TimeTicks deadline;
 297   if (!wait_forever) {
 298     remaining_delta = wait;
 299     deadline = base::TimeTicks::Now() + remaining_delta;
 300   }
 301
 302   result = -1;
 303   struct kevent event = {0};
 304
 305   while (wait_forever || remaining_delta > base::TimeDelta()) {
 306     struct timespec remaining_timespec;
 307     struct timespec* remaining_timespec_ptr;
 308     if (wait_forever) {
 309       remaining_timespec_ptr = NULL;
 310     } else {
 311       remaining_timespec = remaining_delta.ToTimeSpec();
 312       remaining_timespec_ptr = &remaining_timespec;
 313     }
 314
 315     result = kevent(kq.get(), NULL, 0, &event, 1, remaining_timespec_ptr);
 316
 317     if (result == -1 && errno == EINTR) {
 318       if (!wait_forever) {
 319         remaining_delta = deadline - base::TimeTicks::Now();
 320       }
 321       result = 0;
 322     } else {
 323       break;
 324     }
 325   }
 326
 327   if (result < 0) {
 328     DPLOG(ERROR) << "kevent (wait " << handle << ")";
 329     return false;
 330   } else if (result > 1) {
 331     DLOG(ERROR) << "kevent (wait " << handle << "): unexpected result "
 332                 << result;
 333     return false;
 334   } else if (result == 0) {
 335     // Timed out.
 336     return false;
 337   }
 338
 339   DCHECK_EQ(result, 1);
 340
 341   if (event.filter != EVFILT_PROC ||
 342       (event.fflags & NOTE_EXIT) == 0 ||
 343       event.ident != static_cast<uintptr_t>(handle)) {
 344     DLOG(ERROR) << "kevent (wait " << handle
 345                 << "): unexpected event: filter=" << event.filter
 346                 << ", fflags=" << event.fflags
 347                 << ", ident=" << event.ident;
 348     return false;
 349   }
 350
 351   return true;
 352 }
 353 #endif  // OS_MACOSX
 354
 355 bool WaitForSingleProcess(ProcessHandle handle, base::TimeDelta wait) {
 356   ProcessHandle parent_pid = GetParentProcessId(handle);
 357   ProcessHandle our_pid = Process::Current().handle();
 358   if (parent_pid != our_pid) {
 359 #if defined(OS_MACOSX)
 360     // On Mac we can wait on non child processes.
 361     return WaitForSingleNonChildProcess(handle, wait);
 362 #else
 363     // Currently on Linux we can't handle non child processes.
 364     NOTIMPLEMENTED();
 365 #endif  // OS_MACOSX
 366   }
 367
 368   int status;
 369   if (!WaitpidWithTimeout(handle, &status, wait))
 370     return false;
 371   return WIFEXITED(status);
 372 }
 373
 374 bool CleanupProcesses(const FilePath::StringType& executable_name,
 375                       base::TimeDelta wait,
 376                       int exit_code,
 377                       const ProcessFilter* filter) {
 378   bool exited_cleanly = WaitForProcessesToExit(executable_name, wait, filter);
 379   if (!exited_cleanly)
 380     KillProcesses(executable_name, exit_code, filter);
 381   return exited_cleanly;
 382 }
 383
 384 #if !defined(OS_MACOSX)
 385
 386 namespace {
 387
 388 // Return true if the given child is dead. This will also reap the process.
 389 // Doesn't block.
 390 static bool IsChildDead(pid_t child) {
 391   const pid_t result = HANDLE_EINTR(waitpid(child, NULL, WNOHANG));
 392   if (result == -1) {
 393     DPLOG(ERROR) << "waitpid(" << child << ")";
 394     NOTREACHED();
 395   } else if (result > 0) {
 396     // The child has died.
 397     return true;
 398   }
 399
 400   return false;
 401 }
 402
 403 // A thread class which waits for the given child to exit and reaps it.
 404 // If the child doesn't exit within a couple of seconds, kill it.
 405 class BackgroundReaper : public PlatformThread::Delegate {
 406  public:
 407   BackgroundReaper(pid_t child, unsigned timeout)
 408       : child_(child),
 409         timeout_(timeout) {
 410   }
 411
 412   // Overridden from PlatformThread::Delegate:
 413   virtual void ThreadMain() OVERRIDE {
 414     WaitForChildToDie();
 415     delete this;
 416   }
 417
 418   void WaitForChildToDie() {
 419     // Wait forever case.
 420     if (timeout_ == 0) {
 421       pid_t r = HANDLE_EINTR(waitpid(child_, NULL, 0));
 422       if (r != child_) {
 423         DPLOG(ERROR) << "While waiting for " << child_
 424                      << " to terminate, we got the following result: " << r;
 425       }
 426       return;
 427     }
 428
 429     // There's no good way to wait for a specific child to exit in a timed
 430     // fashion. (No kqueue on Linux), so we just loop and sleep.
 431
 432     // Wait for 2 * timeout_ 500 milliseconds intervals.
 433     for (unsigned i = 0; i < 2 * timeout_; ++i) {
 434       PlatformThread::Sleep(TimeDelta::FromMilliseconds(500));
 435       if (IsChildDead(child_))
 436         return;
 437     }
 438
 439     if (kill(child_, SIGKILL) == 0) {
 440       // SIGKILL is uncatchable. Since the signal was delivered, we can
 441       // just wait for the process to die now in a blocking manner.
 442       if (HANDLE_EINTR(waitpid(child_, NULL, 0)) < 0)
 443         DPLOG(WARNING) << "waitpid";
 444     } else {
 445       DLOG(ERROR) << "While waiting for " << child_ << " to terminate we"
 446                   << " failed to deliver a SIGKILL signal (" << errno << ").";
 447     }
 448   }
 449
 450  private:
 451   const pid_t child_;
 452   // Number of seconds to wait, if 0 then wait forever and do not attempt to
 453   // kill |child_|.
 454   const unsigned timeout_;
 455
 456   DISALLOW_COPY_AND_ASSIGN(BackgroundReaper);
 457 };
 458
 459 }  // namespace
 460
 461 void EnsureProcessTerminated(ProcessHandle process) {
 462   // If the child is already dead, then there's nothing to do.
 463   if (IsChildDead(process))
 464     return;
 465
 466   const unsigned timeout = 2;  // seconds
 467   BackgroundReaper* reaper = new BackgroundReaper(process, timeout);
 468   PlatformThread::CreateNonJoinable(0, reaper);
 469 }
 470
 471 void EnsureProcessGetsReaped(ProcessHandle process) {
 472   // If the child is already dead, then there's nothing to do.
 473   if (IsChildDead(process))
 474     return;
 475
 476   BackgroundReaper* reaper = new BackgroundReaper(process, 0);
 477   PlatformThread::CreateNonJoinable(0, reaper);
 478 }
 479
 480 #endif  // !defined(OS_MACOSX)
 481
 482 }  // namespace base