| // 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 |