• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <errno.h>
8 #include <signal.h>
9 #include <sys/types.h>
10 #include <sys/wait.h>
11 #include <unistd.h>
12 
13 #include "base/files/file_util.h"
14 #include "base/files/scoped_file.h"
15 #include "base/logging.h"
16 #include "base/macros.h"
17 #include "base/posix/eintr_wrapper.h"
18 #include "base/process/process_iterator.h"
19 #include "base/synchronization/waitable_event.h"
20 #include "base/threading/platform_thread.h"
21 #include "build/build_config.h"
22 
23 namespace base {
24 
25 namespace {
26 
GetTerminationStatusImpl(ProcessHandle handle,bool can_block,int * exit_code)27 TerminationStatus GetTerminationStatusImpl(ProcessHandle handle,
28                                            bool can_block,
29                                            int* exit_code) {
30   int status = 0;
31   const pid_t result = HANDLE_EINTR(waitpid(handle, &status,
32                                             can_block ? 0 : WNOHANG));
33   if (result == -1) {
34     DPLOG(ERROR) << "waitpid(" << handle << ")";
35     if (exit_code)
36       *exit_code = 0;
37     return TERMINATION_STATUS_NORMAL_TERMINATION;
38   } else if (result == 0) {
39     // the child hasn't exited yet.
40     if (exit_code)
41       *exit_code = 0;
42     return TERMINATION_STATUS_STILL_RUNNING;
43   }
44 
45   if (exit_code)
46     *exit_code = status;
47 
48   if (WIFSIGNALED(status)) {
49     switch (WTERMSIG(status)) {
50       case SIGABRT:
51       case SIGBUS:
52       case SIGFPE:
53       case SIGILL:
54       case SIGSEGV:
55       case SIGTRAP:
56       case SIGSYS:
57         return TERMINATION_STATUS_PROCESS_CRASHED;
58       case SIGKILL:
59 #if defined(OS_CHROMEOS)
60         // On ChromeOS, only way a process gets kill by SIGKILL
61         // is by oom-killer.
62         return TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM;
63 #endif
64       case SIGINT:
65       case SIGTERM:
66         return TERMINATION_STATUS_PROCESS_WAS_KILLED;
67       default:
68         break;
69     }
70   }
71 
72   if (WIFEXITED(status) && WEXITSTATUS(status) != 0)
73     return TERMINATION_STATUS_ABNORMAL_TERMINATION;
74 
75   return TERMINATION_STATUS_NORMAL_TERMINATION;
76 }
77 
78 }  // namespace
79 
80 #if !defined(OS_NACL_NONSFI)
KillProcessGroup(ProcessHandle process_group_id)81 bool KillProcessGroup(ProcessHandle process_group_id) {
82   bool result = kill(-1 * process_group_id, SIGKILL) == 0;
83   if (!result)
84     DPLOG(ERROR) << "Unable to terminate process group " << process_group_id;
85   return result;
86 }
87 #endif  // !defined(OS_NACL_NONSFI)
88 
GetTerminationStatus(ProcessHandle handle,int * exit_code)89 TerminationStatus GetTerminationStatus(ProcessHandle handle, int* exit_code) {
90   return GetTerminationStatusImpl(handle, false /* can_block */, exit_code);
91 }
92 
GetKnownDeadTerminationStatus(ProcessHandle handle,int * exit_code)93 TerminationStatus GetKnownDeadTerminationStatus(ProcessHandle handle,
94                                                 int* exit_code) {
95   bool result = kill(handle, SIGKILL) == 0;
96 
97   if (!result)
98     DPLOG(ERROR) << "Unable to terminate process " << handle;
99 
100   return GetTerminationStatusImpl(handle, true /* can_block */, exit_code);
101 }
102 
103 #if !defined(OS_NACL_NONSFI)
WaitForProcessesToExit(const FilePath::StringType & executable_name,TimeDelta wait,const ProcessFilter * filter)104 bool WaitForProcessesToExit(const FilePath::StringType& executable_name,
105                             TimeDelta wait,
106                             const ProcessFilter* filter) {
107   bool result = false;
108 
109   // TODO(port): This is inefficient, but works if there are multiple procs.
110   // TODO(port): use waitpid to avoid leaving zombies around
111 
112   TimeTicks end_time = TimeTicks::Now() + wait;
113   do {
114     NamedProcessIterator iter(executable_name, filter);
115     if (!iter.NextProcessEntry()) {
116       result = true;
117       break;
118     }
119     PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
120   } while ((end_time - TimeTicks::Now()) > TimeDelta());
121 
122   return result;
123 }
124 
CleanupProcesses(const FilePath::StringType & executable_name,TimeDelta wait,int exit_code,const ProcessFilter * filter)125 bool CleanupProcesses(const FilePath::StringType& executable_name,
126                       TimeDelta wait,
127                       int exit_code,
128                       const ProcessFilter* filter) {
129   bool exited_cleanly = WaitForProcessesToExit(executable_name, wait, filter);
130   if (!exited_cleanly)
131     KillProcesses(executable_name, exit_code, filter);
132   return exited_cleanly;
133 }
134 
135 #if !defined(OS_MACOSX)
136 
137 namespace {
138 
139 // Return true if the given child is dead. This will also reap the process.
140 // Doesn't block.
IsChildDead(pid_t child)141 static bool IsChildDead(pid_t child) {
142   const pid_t result = HANDLE_EINTR(waitpid(child, NULL, WNOHANG));
143   if (result == -1) {
144     DPLOG(ERROR) << "waitpid(" << child << ")";
145     NOTREACHED();
146   } else if (result > 0) {
147     // The child has died.
148     return true;
149   }
150 
151   return false;
152 }
153 
154 // A thread class which waits for the given child to exit and reaps it.
155 // If the child doesn't exit within a couple of seconds, kill it.
156 class BackgroundReaper : public PlatformThread::Delegate {
157  public:
BackgroundReaper(pid_t child,unsigned timeout)158   BackgroundReaper(pid_t child, unsigned timeout)
159       : child_(child),
160         timeout_(timeout) {
161   }
162 
163   // Overridden from PlatformThread::Delegate:
ThreadMain()164   void ThreadMain() override {
165     WaitForChildToDie();
166     delete this;
167   }
168 
WaitForChildToDie()169   void WaitForChildToDie() {
170     // Wait forever case.
171     if (timeout_ == 0) {
172       pid_t r = HANDLE_EINTR(waitpid(child_, NULL, 0));
173       if (r != child_) {
174         DPLOG(ERROR) << "While waiting for " << child_
175                      << " to terminate, we got the following result: " << r;
176       }
177       return;
178     }
179 
180     // There's no good way to wait for a specific child to exit in a timed
181     // fashion. (No kqueue on Linux), so we just loop and sleep.
182 
183     // Wait for 2 * timeout_ 500 milliseconds intervals.
184     for (unsigned i = 0; i < 2 * timeout_; ++i) {
185       PlatformThread::Sleep(TimeDelta::FromMilliseconds(500));
186       if (IsChildDead(child_))
187         return;
188     }
189 
190     if (kill(child_, SIGKILL) == 0) {
191       // SIGKILL is uncatchable. Since the signal was delivered, we can
192       // just wait for the process to die now in a blocking manner.
193       if (HANDLE_EINTR(waitpid(child_, NULL, 0)) < 0)
194         DPLOG(WARNING) << "waitpid";
195     } else {
196       DLOG(ERROR) << "While waiting for " << child_ << " to terminate we"
197                   << " failed to deliver a SIGKILL signal (" << errno << ").";
198     }
199   }
200 
201  private:
202   const pid_t child_;
203   // Number of seconds to wait, if 0 then wait forever and do not attempt to
204   // kill |child_|.
205   const unsigned timeout_;
206 
207   DISALLOW_COPY_AND_ASSIGN(BackgroundReaper);
208 };
209 
210 }  // namespace
211 
EnsureProcessTerminated(Process process)212 void EnsureProcessTerminated(Process process) {
213   // If the child is already dead, then there's nothing to do.
214   if (IsChildDead(process.Pid()))
215     return;
216 
217   const unsigned timeout = 2;  // seconds
218   BackgroundReaper* reaper = new BackgroundReaper(process.Pid(), timeout);
219   PlatformThread::CreateNonJoinable(0, reaper);
220 }
221 
EnsureProcessGetsReaped(ProcessId pid)222 void EnsureProcessGetsReaped(ProcessId pid) {
223   // If the child is already dead, then there's nothing to do.
224   if (IsChildDead(pid))
225     return;
226 
227   BackgroundReaper* reaper = new BackgroundReaper(pid, 0);
228   PlatformThread::CreateNonJoinable(0, reaper);
229 }
230 
231 #endif  // !defined(OS_MACOSX)
232 #endif  // !defined(OS_NACL_NONSFI)
233 
234 }  // namespace base
235