| // 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/process_metrics.h" |
| |
| #include <windows.h> // Must be in front of other Windows header files. |
| |
| #include <psapi.h> |
| #include <stddef.h> |
| #include <stdint.h> |
| #include <winternl.h> |
| |
| #include <algorithm> |
| |
| #include "base/logging.h" |
| #include "base/memory/ptr_util.h" |
| #include "base/process/memory.h" |
| #include "base/process/process_metrics_iocounters.h" |
| #include "base/sys_info.h" |
| |
| namespace base { |
| namespace { |
| |
| // System pagesize. This value remains constant on x86/64 architectures. |
| const int PAGESIZE_KB = 4; |
| |
| typedef NTSTATUS(WINAPI* NTQUERYSYSTEMINFORMATION)( |
| SYSTEM_INFORMATION_CLASS SystemInformationClass, |
| PVOID SystemInformation, |
| ULONG SystemInformationLength, |
| PULONG ReturnLength); |
| |
| } // namespace |
| |
| ProcessMetrics::~ProcessMetrics() { } |
| |
| size_t GetMaxFds() { |
| // Windows is only limited by the amount of physical memory. |
| return std::numeric_limits<size_t>::max(); |
| } |
| |
| // static |
| std::unique_ptr<ProcessMetrics> ProcessMetrics::CreateProcessMetrics( |
| ProcessHandle process) { |
| return WrapUnique(new ProcessMetrics(process)); |
| } |
| |
| namespace { |
| |
| class WorkingSetInformationBuffer { |
| public: |
| WorkingSetInformationBuffer() {} |
| ~WorkingSetInformationBuffer() { Clear(); } |
| |
| bool Reserve(size_t size) { |
| Clear(); |
| // Use UncheckedMalloc here because this can be called from the code |
| // that handles low memory condition. |
| return UncheckedMalloc(size, reinterpret_cast<void**>(&buffer_)); |
| } |
| |
| const PSAPI_WORKING_SET_INFORMATION* operator ->() const { return buffer_; } |
| |
| size_t GetPageEntryCount() const { return number_of_entries; } |
| |
| // This function is used to get page entries for a process. |
| bool QueryPageEntries(const ProcessHandle& process) { |
| int retries = 5; |
| number_of_entries = 4096; // Just a guess. |
| |
| for (;;) { |
| size_t buffer_size = |
| sizeof(PSAPI_WORKING_SET_INFORMATION) + |
| (number_of_entries * sizeof(PSAPI_WORKING_SET_BLOCK)); |
| |
| if (!Reserve(buffer_size)) |
| return false; |
| |
| // On success, |buffer_| is populated with info about the working set of |
| // |process|. On ERROR_BAD_LENGTH failure, increase the size of the |
| // buffer and try again. |
| if (QueryWorkingSet(process, buffer_, buffer_size)) |
| break; // Success |
| |
| if (GetLastError() != ERROR_BAD_LENGTH) |
| return false; |
| |
| number_of_entries = buffer_->NumberOfEntries; |
| |
| // Maybe some entries are being added right now. Increase the buffer to |
| // take that into account. Increasing by 10% should generally be enough, |
| // especially considering the potentially low memory condition during the |
| // call (when called from OomMemoryDetails) and the potentially high |
| // number of entries (300K was observed in crash dumps). |
| number_of_entries *= 1.1; |
| |
| if (--retries == 0) { |
| // If we're looping, eventually fail. |
| return false; |
| } |
| } |
| |
| // TODO(chengx): Remove the comment and the logic below. It is no longer |
| // needed since we don't have Win2000 support. |
| // On windows 2000 the function returns 1 even when the buffer is too small. |
| // The number of entries that we are going to parse is the minimum between |
| // the size we allocated and the real number of entries. |
| number_of_entries = std::min(number_of_entries, |
| static_cast<size_t>(buffer_->NumberOfEntries)); |
| |
| return true; |
| } |
| |
| private: |
| void Clear() { |
| free(buffer_); |
| buffer_ = nullptr; |
| } |
| |
| PSAPI_WORKING_SET_INFORMATION* buffer_ = nullptr; |
| |
| // Number of page entries. |
| size_t number_of_entries = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(WorkingSetInformationBuffer); |
| }; |
| |
| } // namespace |
| |
| TimeDelta ProcessMetrics::GetCumulativeCPUUsage() { |
| FILETIME creation_time; |
| FILETIME exit_time; |
| FILETIME kernel_time; |
| FILETIME user_time; |
| |
| if (!GetProcessTimes(process_.Get(), &creation_time, &exit_time, &kernel_time, |
| &user_time)) { |
| // We don't assert here because in some cases (such as in the Task Manager) |
| // we may call this function on a process that has just exited but we have |
| // not yet received the notification. |
| return TimeDelta(); |
| } |
| |
| return TimeDelta::FromFileTime(kernel_time) + |
| TimeDelta::FromFileTime(user_time); |
| } |
| |
| bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const { |
| return GetProcessIoCounters(process_.Get(), io_counters) != FALSE; |
| } |
| |
| ProcessMetrics::ProcessMetrics(ProcessHandle process) { |
| if (process) { |
| HANDLE duplicate_handle = INVALID_HANDLE_VALUE; |
| BOOL result = ::DuplicateHandle(::GetCurrentProcess(), process, |
| ::GetCurrentProcess(), &duplicate_handle, |
| PROCESS_QUERY_INFORMATION, FALSE, 0); |
| DPCHECK(result); |
| process_.Set(duplicate_handle); |
| } |
| } |
| |
| size_t GetSystemCommitCharge() { |
| // Get the System Page Size. |
| SYSTEM_INFO system_info; |
| GetSystemInfo(&system_info); |
| |
| PERFORMANCE_INFORMATION info; |
| if (!GetPerformanceInfo(&info, sizeof(info))) { |
| DLOG(ERROR) << "Failed to fetch internal performance info."; |
| return 0; |
| } |
| return (info.CommitTotal * system_info.dwPageSize) / 1024; |
| } |
| |
| size_t GetPageSize() { |
| return PAGESIZE_KB * 1024; |
| } |
| |
| // This function uses the following mapping between MEMORYSTATUSEX and |
| // SystemMemoryInfoKB: |
| // ullTotalPhys ==> total |
| // ullAvailPhys ==> avail_phys |
| // ullTotalPageFile ==> swap_total |
| // ullAvailPageFile ==> swap_free |
| bool GetSystemMemoryInfo(SystemMemoryInfoKB* meminfo) { |
| MEMORYSTATUSEX mem_status; |
| mem_status.dwLength = sizeof(mem_status); |
| if (!::GlobalMemoryStatusEx(&mem_status)) |
| return false; |
| |
| meminfo->total = mem_status.ullTotalPhys / 1024; |
| meminfo->avail_phys = mem_status.ullAvailPhys / 1024; |
| meminfo->swap_total = mem_status.ullTotalPageFile / 1024; |
| meminfo->swap_free = mem_status.ullAvailPageFile / 1024; |
| |
| return true; |
| } |
| |
| size_t ProcessMetrics::GetMallocUsage() { |
| // Unsupported as getting malloc usage on Windows requires iterating through |
| // the heap which is slow and crashes. |
| return 0; |
| } |
| |
| } // namespace base |