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