// Copyright (c) 2013 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "base/process/kill.h" #include <errno.h> #include <signal.h> #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> #include "base/files/file_util.h" #include "base/files/scoped_file.h" #include "base/logging.h" #include "base/macros.h" #include "base/posix/eintr_wrapper.h" #include "base/process/process_iterator.h" #include "base/synchronization/waitable_event.h" #include "base/threading/platform_thread.h" #include "build/build_config.h" namespace base { namespace { TerminationStatus GetTerminationStatusImpl(ProcessHandle handle, bool can_block, int* exit_code) { int status = 0; const pid_t result = HANDLE_EINTR(waitpid(handle, &status, can_block ? 0 : WNOHANG)); if (result == -1) { DPLOG(ERROR) << "waitpid(" << handle << ")"; if (exit_code) *exit_code = 0; return TERMINATION_STATUS_NORMAL_TERMINATION; } else if (result == 0) { // the child hasn't exited yet. if (exit_code) *exit_code = 0; return TERMINATION_STATUS_STILL_RUNNING; } if (exit_code) *exit_code = status; if (WIFSIGNALED(status)) { switch (WTERMSIG(status)) { case SIGABRT: case SIGBUS: case SIGFPE: case SIGILL: case SIGSEGV: return TERMINATION_STATUS_PROCESS_CRASHED; case SIGKILL: #if defined(OS_CHROMEOS) // On ChromeOS, only way a process gets kill by SIGKILL // is by oom-killer. return TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM; #endif case SIGINT: case SIGTERM: return TERMINATION_STATUS_PROCESS_WAS_KILLED; default: break; } } if (WIFEXITED(status) && WEXITSTATUS(status) != 0) return TERMINATION_STATUS_ABNORMAL_TERMINATION; return TERMINATION_STATUS_NORMAL_TERMINATION; } } // namespace #if !defined(OS_NACL_NONSFI) bool KillProcessGroup(ProcessHandle process_group_id) { bool result = kill(-1 * process_group_id, SIGKILL) == 0; if (!result) DPLOG(ERROR) << "Unable to terminate process group " << process_group_id; return result; } #endif // !defined(OS_NACL_NONSFI) TerminationStatus GetTerminationStatus(ProcessHandle handle, int* exit_code) { return GetTerminationStatusImpl(handle, false /* can_block */, exit_code); } TerminationStatus GetKnownDeadTerminationStatus(ProcessHandle handle, int* exit_code) { bool result = kill(handle, SIGKILL) == 0; if (!result) DPLOG(ERROR) << "Unable to terminate process " << handle; return GetTerminationStatusImpl(handle, true /* can_block */, exit_code); } #if !defined(OS_NACL_NONSFI) bool WaitForProcessesToExit(const FilePath::StringType& executable_name, TimeDelta wait, const ProcessFilter* filter) { bool result = false; // TODO(port): This is inefficient, but works if there are multiple procs. // TODO(port): use waitpid to avoid leaving zombies around TimeTicks end_time = TimeTicks::Now() + wait; do { NamedProcessIterator iter(executable_name, filter); if (!iter.NextProcessEntry()) { result = true; break; } PlatformThread::Sleep(TimeDelta::FromMilliseconds(100)); } while ((end_time - TimeTicks::Now()) > TimeDelta()); return result; } bool CleanupProcesses(const FilePath::StringType& executable_name, TimeDelta wait, int exit_code, const ProcessFilter* filter) { bool exited_cleanly = WaitForProcessesToExit(executable_name, wait, filter); if (!exited_cleanly) KillProcesses(executable_name, exit_code, filter); return exited_cleanly; } #if !defined(OS_MACOSX) namespace { // Return true if the given child is dead. This will also reap the process. // Doesn't block. static bool IsChildDead(pid_t child) { const pid_t result = HANDLE_EINTR(waitpid(child, NULL, WNOHANG)); if (result == -1) { DPLOG(ERROR) << "waitpid(" << child << ")"; NOTREACHED(); } else if (result > 0) { // The child has died. return true; } return false; } // A thread class which waits for the given child to exit and reaps it. // If the child doesn't exit within a couple of seconds, kill it. class BackgroundReaper : public PlatformThread::Delegate { public: BackgroundReaper(pid_t child, unsigned timeout) : child_(child), timeout_(timeout) { } // Overridden from PlatformThread::Delegate: void ThreadMain() override { WaitForChildToDie(); delete this; } void WaitForChildToDie() { // Wait forever case. if (timeout_ == 0) { pid_t r = HANDLE_EINTR(waitpid(child_, NULL, 0)); if (r != child_) { DPLOG(ERROR) << "While waiting for " << child_ << " to terminate, we got the following result: " << r; } return; } // There's no good way to wait for a specific child to exit in a timed // fashion. (No kqueue on Linux), so we just loop and sleep. // Wait for 2 * timeout_ 500 milliseconds intervals. for (unsigned i = 0; i < 2 * timeout_; ++i) { PlatformThread::Sleep(TimeDelta::FromMilliseconds(500)); if (IsChildDead(child_)) return; } if (kill(child_, SIGKILL) == 0) { // SIGKILL is uncatchable. Since the signal was delivered, we can // just wait for the process to die now in a blocking manner. if (HANDLE_EINTR(waitpid(child_, NULL, 0)) < 0) DPLOG(WARNING) << "waitpid"; } else { DLOG(ERROR) << "While waiting for " << child_ << " to terminate we" << " failed to deliver a SIGKILL signal (" << errno << ")."; } } private: const pid_t child_; // Number of seconds to wait, if 0 then wait forever and do not attempt to // kill |child_|. const unsigned timeout_; DISALLOW_COPY_AND_ASSIGN(BackgroundReaper); }; } // namespace void EnsureProcessTerminated(Process process) { // If the child is already dead, then there's nothing to do. if (IsChildDead(process.Pid())) return; const unsigned timeout = 2; // seconds BackgroundReaper* reaper = new BackgroundReaper(process.Pid(), timeout); PlatformThread::CreateNonJoinable(0, reaper); } void EnsureProcessGetsReaped(ProcessId pid) { // If the child is already dead, then there's nothing to do. if (IsChildDead(pid)) return; BackgroundReaper* reaper = new BackgroundReaper(pid, 0); PlatformThread::CreateNonJoinable(0, reaper); } #endif // !defined(OS_MACOSX) #endif // !defined(OS_NACL_NONSFI) } // namespace base