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