| // Copyright (c) 2006-2008 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 <dirent.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <signal.h> |
| #include <stdlib.h> |
| #include <sys/resource.h> |
| #include <sys/time.h> |
| #include <sys/types.h> |
| #include <sys/wait.h> |
| #include <unistd.h> |
| |
| #include <limits> |
| |
| #include "base/basictypes.h" |
| #include "base/logging.h" |
| #include "base/platform_thread.h" |
| #include "base/process_util.h" |
| #include "base/scoped_ptr.h" |
| #include "base/sys_info.h" |
| #include "base/time.h" |
| |
| const int kMicrosecondsPerSecond = 1000000; |
| |
| namespace base { |
| |
| ProcessId GetCurrentProcId() { |
| return getpid(); |
| } |
| |
| ProcessHandle GetCurrentProcessHandle() { |
| return GetCurrentProcId(); |
| } |
| |
| ProcessHandle OpenProcessHandle(ProcessId pid) { |
| // On Posix platforms, process handles are the same as PIDs, so we |
| // don't need to do anything. |
| return pid; |
| } |
| |
| void CloseProcessHandle(ProcessHandle process) { |
| // See OpenProcessHandle, nothing to do. |
| return; |
| } |
| |
| ProcessId GetProcId(ProcessHandle process) { |
| return process; |
| } |
| |
| // Attempts to kill the process identified by the given process |
| // entry structure. Ignores specified exit_code; posix can't force that. |
| // Returns true if this is successful, false otherwise. |
| bool KillProcess(ProcessHandle process_id, int exit_code, bool wait) { |
| bool result = false; |
| |
| int status = kill(process_id, SIGTERM); |
| if (!status && wait) { |
| int tries = 60; |
| // The process may not end immediately due to pending I/O |
| while (tries-- > 0) { |
| int pid = waitpid(process_id, &status, WNOHANG); |
| if (pid == process_id) { |
| result = true; |
| break; |
| } |
| sleep(1); |
| } |
| } |
| if (!result) |
| DLOG(ERROR) << "Unable to terminate process."; |
| return result; |
| } |
| |
| // A class to handle auto-closing of DIR*'s. |
| class ScopedDIRClose { |
| public: |
| inline void operator()(DIR* x) const { |
| if (x) { |
| closedir(x); |
| } |
| } |
| }; |
| typedef scoped_ptr_malloc<DIR, ScopedDIRClose> ScopedDIR; |
| |
| // Sets all file descriptors to close on exec except for stdin, stdout |
| // and stderr. |
| void SetAllFDsToCloseOnExec() { |
| #if defined(OS_LINUX) |
| const char fd_dir[] = "/proc/self/fd"; |
| #elif defined(OS_MACOSX) |
| const char fd_dir[] = "/dev/fd"; |
| #endif |
| ScopedDIR dir_closer(opendir(fd_dir)); |
| DIR *dir = dir_closer.get(); |
| if (NULL == dir) { |
| DLOG(ERROR) << "Unable to open " << fd_dir; |
| return; |
| } |
| |
| struct dirent *ent; |
| while ((ent = readdir(dir))) { |
| // Skip . and .. entries. |
| if (ent->d_name[0] == '.') |
| continue; |
| int i = atoi(ent->d_name); |
| // We don't close stdin, stdout or stderr. |
| if (i <= STDERR_FILENO) |
| continue; |
| |
| int flags = fcntl(i, F_GETFD); |
| if ((flags == -1) || (fcntl(i, F_SETFD, flags | FD_CLOEXEC) == -1)) { |
| DLOG(ERROR) << "fcntl failure."; |
| } |
| } |
| } |
| |
| ProcessMetrics::ProcessMetrics(ProcessHandle process) : process_(process), |
| last_time_(0), |
| last_system_time_(0) { |
| processor_count_ = base::SysInfo::NumberOfProcessors(); |
| } |
| |
| // static |
| ProcessMetrics* ProcessMetrics::CreateProcessMetrics(ProcessHandle process) { |
| return new ProcessMetrics(process); |
| } |
| |
| ProcessMetrics::~ProcessMetrics() { } |
| |
| void EnableTerminationOnHeapCorruption() { |
| // On POSIX, there nothing to do AFAIK. |
| } |
| |
| void RaiseProcessToHighPriority() { |
| // On POSIX, we don't actually do anything here. We could try to nice() or |
| // setpriority() or sched_getscheduler, but these all require extra rights. |
| } |
| |
| bool DidProcessCrash(ProcessHandle handle) { |
| int status; |
| if (waitpid(handle, &status, WNOHANG)) { |
| // I feel like dancing! |
| return false; |
| } |
| |
| if (WIFSIGNALED(status)) { |
| switch(WTERMSIG(status)) { |
| case SIGSEGV: |
| case SIGILL: |
| case SIGABRT: |
| case SIGFPE: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| if (WIFEXITED(status)) |
| return WEXITSTATUS(status) != 0; |
| |
| return false; |
| } |
| |
| bool WaitForExitCode(ProcessHandle handle, int* exit_code) { |
| int status; |
| while (waitpid(handle, &status, 0) == -1) { |
| if (errno != EINTR) { |
| NOTREACHED(); |
| return false; |
| } |
| } |
| |
| if (WIFEXITED(status)) { |
| *exit_code = WEXITSTATUS(status); |
| return true; |
| } |
| |
| // If it didn't exit cleanly, it must have been signaled. |
| DCHECK(WIFSIGNALED(status)); |
| return false; |
| } |
| |
| namespace { |
| |
| int WaitpidWithTimeout(ProcessHandle handle, int wait_milliseconds, |
| bool* success) { |
| // This POSIX version of this function only guarantees that we wait no less |
| // than |wait_milliseconds| for the proces to exit. The child process may |
| // exit sometime before the timeout has ended but we may still block for |
| // up to 0.25 seconds after the fact. |
| // |
| // waitpid() has no direct support on POSIX for specifying a timeout, you can |
| // either ask it to block indefinitely or return immediately (WNOHANG). |
| // When a child process terminates a SIGCHLD signal is sent to the parent. |
| // Catching this signal would involve installing a signal handler which may |
| // affect other parts of the application and would be difficult to debug. |
| // |
| // Our strategy is to call waitpid() once up front to check if the process |
| // has already exited, otherwise to loop for wait_milliseconds, sleeping for |
| // at most 0.25 secs each time using usleep() and then calling waitpid(). |
| // |
| // usleep() is speced to exit if a signal is received for which a handler |
| // has been installed. This means that when a SIGCHLD is sent, it will exit |
| // depending on behavior external to this function. |
| // |
| // This function is used primarilly for unit tests, if we want to use it in |
| // the application itself it would probably be best to examine other routes. |
| int status = -1; |
| pid_t ret_pid = waitpid(handle, &status, WNOHANG); |
| static const int64 kQuarterSecondInMicroseconds = kMicrosecondsPerSecond/4; |
| |
| // If the process hasn't exited yet, then sleep and try again. |
| Time wakeup_time = Time::Now() + TimeDelta::FromMilliseconds( |
| wait_milliseconds); |
| while (ret_pid == 0) { |
| Time now = Time::Now(); |
| if (now > wakeup_time) |
| break; |
| // Guaranteed to be non-negative! |
| int64 sleep_time_usecs = (wakeup_time - now).InMicroseconds(); |
| // Don't sleep for more than 0.25 secs at a time. |
| if (sleep_time_usecs > kQuarterSecondInMicroseconds) { |
| sleep_time_usecs = kQuarterSecondInMicroseconds; |
| } |
| |
| // usleep() will return 0 and set errno to EINTR on receipt of a signal |
| // such as SIGCHLD. |
| usleep(sleep_time_usecs); |
| ret_pid = waitpid(handle, &status, WNOHANG); |
| } |
| |
| if (success) |
| *success = (ret_pid != -1); |
| |
| return status; |
| } |
| |
| } // namespace |
| |
| bool WaitForSingleProcess(ProcessHandle handle, int wait_milliseconds) { |
| bool waitpid_success; |
| int status = WaitpidWithTimeout(handle, wait_milliseconds, &waitpid_success); |
| if (status != -1) { |
| DCHECK(waitpid_success); |
| return WIFEXITED(status); |
| } else { |
| return false; |
| } |
| } |
| |
| bool CrashAwareSleep(ProcessHandle handle, int wait_milliseconds) { |
| bool waitpid_success; |
| int status = WaitpidWithTimeout(handle, wait_milliseconds, &waitpid_success); |
| if (status != -1) { |
| DCHECK(waitpid_success); |
| return !(WIFEXITED(status) || WIFSIGNALED(status)); |
| } else { |
| // If waitpid returned with an error, then the process doesn't exist |
| // (which most probably means it didn't exist before our call). |
| return waitpid_success; |
| } |
| } |
| |
| namespace { |
| |
| int64 TimeValToMicroseconds(const struct timeval& tv) { |
| return tv.tv_sec * kMicrosecondsPerSecond + tv.tv_usec; |
| } |
| |
| } |
| |
| int ProcessMetrics::GetCPUUsage() { |
| struct timeval now; |
| struct rusage usage; |
| |
| int retval = gettimeofday(&now, NULL); |
| if (retval) |
| return 0; |
| retval = getrusage(RUSAGE_SELF, &usage); |
| if (retval) |
| return 0; |
| |
| int64 system_time = (TimeValToMicroseconds(usage.ru_stime) + |
| TimeValToMicroseconds(usage.ru_utime)) / |
| processor_count_; |
| int64 time = TimeValToMicroseconds(now); |
| |
| if ((last_system_time_ == 0) || (last_time_ == 0)) { |
| // First call, just set the last values. |
| last_system_time_ = system_time; |
| last_time_ = time; |
| return 0; |
| } |
| |
| int64 system_time_delta = system_time - last_system_time_; |
| int64 time_delta = time - last_time_; |
| DCHECK(time_delta != 0); |
| if (time_delta == 0) |
| return 0; |
| |
| // We add time_delta / 2 so the result is rounded. |
| int cpu = static_cast<int>((system_time_delta * 100 + time_delta / 2) / |
| time_delta); |
| |
| last_system_time_ = system_time; |
| last_time_ = time; |
| |
| return cpu; |
| } |
| |
| int GetProcessCount(const std::wstring& executable_name, |
| const ProcessFilter* filter) { |
| int count = 0; |
| |
| NamedProcessIterator iter(executable_name, filter); |
| while (iter.NextProcessEntry()) |
| ++count; |
| return count; |
| } |
| |
| bool KillProcesses(const std::wstring& executable_name, int exit_code, |
| const ProcessFilter* filter) { |
| bool result = true; |
| const ProcessEntry* entry; |
| |
| NamedProcessIterator iter(executable_name, filter); |
| while ((entry = iter.NextProcessEntry()) != NULL) |
| result = KillProcess((*entry).pid, exit_code, true) && result; |
| |
| return result; |
| } |
| |
| bool WaitForProcessesToExit(const std::wstring& executable_name, |
| int wait_milliseconds, |
| 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 |
| |
| base::Time end_time = base::Time::Now() + |
| base::TimeDelta::FromMilliseconds(wait_milliseconds); |
| do { |
| NamedProcessIterator iter(executable_name, filter); |
| if (!iter.NextProcessEntry()) { |
| result = true; |
| break; |
| } |
| PlatformThread::Sleep(100); |
| } while ((base::Time::Now() - end_time) > base::TimeDelta()); |
| |
| return result; |
| } |
| |
| bool CleanupProcesses(const std::wstring& executable_name, |
| int wait_milliseconds, |
| int exit_code, |
| const ProcessFilter* filter) { |
| bool exited_cleanly = |
| WaitForProcessesToExit(executable_name, wait_milliseconds, |
| filter); |
| if (!exited_cleanly) |
| KillProcesses(executable_name, exit_code, filter); |
| return exited_cleanly; |
| } |
| |
| } // namespace base |