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