// 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 <mach/mach.h> #include <mach/mach_vm.h> #include <mach/shared_region.h> #include <stddef.h> #include <stdint.h> #include <sys/sysctl.h> #include "base/containers/hash_tables.h" #include "base/logging.h" #include "base/mac/mach_logging.h" #include "base/mac/scoped_mach_port.h" #include "base/sys_info.h" #if !defined(TASK_POWER_INFO) // Doesn't exist in the 10.6 or 10.7 SDKs. #define TASK_POWER_INFO 21 struct task_power_info { uint64_t total_user; uint64_t total_system; uint64_t task_interrupt_wakeups; uint64_t task_platform_idle_wakeups; uint64_t task_timer_wakeups_bin_1; uint64_t task_timer_wakeups_bin_2; }; typedef struct task_power_info task_power_info_data_t; typedef struct task_power_info *task_power_info_t; #define TASK_POWER_INFO_COUNT ((mach_msg_type_number_t) \ (sizeof (task_power_info_data_t) / sizeof (natural_t))) #endif namespace base { namespace { bool GetTaskInfo(mach_port_t task, task_basic_info_64* task_info_data) { if (task == MACH_PORT_NULL) return false; mach_msg_type_number_t count = TASK_BASIC_INFO_64_COUNT; kern_return_t kr = task_info(task, TASK_BASIC_INFO_64, reinterpret_cast<task_info_t>(task_info_data), &count); // Most likely cause for failure: |task| is a zombie. return kr == KERN_SUCCESS; } bool GetCPUTypeForProcess(pid_t /* pid */, cpu_type_t* cpu_type) { size_t len = sizeof(*cpu_type); int result = sysctlbyname("sysctl.proc_cputype", cpu_type, &len, NULL, 0); if (result != 0) { DPLOG(ERROR) << "sysctlbyname(""sysctl.proc_cputype"")"; return false; } return true; } bool IsAddressInSharedRegion(mach_vm_address_t addr, cpu_type_t type) { if (type == CPU_TYPE_I386) { return addr >= SHARED_REGION_BASE_I386 && addr < (SHARED_REGION_BASE_I386 + SHARED_REGION_SIZE_I386); } else if (type == CPU_TYPE_X86_64) { return addr >= SHARED_REGION_BASE_X86_64 && addr < (SHARED_REGION_BASE_X86_64 + SHARED_REGION_SIZE_X86_64); } else { return false; } } } // namespace SystemMemoryInfoKB::SystemMemoryInfoKB() { total = 0; free = 0; } // Getting a mach task from a pid for another process requires permissions in // general, so there doesn't really seem to be a way to do these (and spinning // up ps to fetch each stats seems dangerous to put in a base api for anyone to // call). Child processes ipc their port, so return something if available, // otherwise return 0. // static ProcessMetrics* ProcessMetrics::CreateProcessMetrics( ProcessHandle process, PortProvider* port_provider) { return new ProcessMetrics(process, port_provider); } size_t ProcessMetrics::GetPagefileUsage() const { task_basic_info_64 task_info_data; if (!GetTaskInfo(TaskForPid(process_), &task_info_data)) return 0; return task_info_data.virtual_size; } size_t ProcessMetrics::GetPeakPagefileUsage() const { return 0; } size_t ProcessMetrics::GetWorkingSetSize() const { task_basic_info_64 task_info_data; if (!GetTaskInfo(TaskForPid(process_), &task_info_data)) return 0; return task_info_data.resident_size; } size_t ProcessMetrics::GetPeakWorkingSetSize() const { return 0; } // This is a rough approximation of the algorithm that libtop uses. // private_bytes is the size of private resident memory. // shared_bytes is the size of shared resident memory. bool ProcessMetrics::GetMemoryBytes(size_t* private_bytes, size_t* shared_bytes) { size_t private_pages_count = 0; size_t shared_pages_count = 0; if (!private_bytes && !shared_bytes) return true; mach_port_t task = TaskForPid(process_); if (task == MACH_PORT_NULL) { DLOG(ERROR) << "Invalid process"; return false; } cpu_type_t cpu_type; if (!GetCPUTypeForProcess(process_, &cpu_type)) return false; // The same region can be referenced multiple times. To avoid double counting // we need to keep track of which regions we've already counted. base::hash_set<int> seen_objects; // We iterate through each VM region in the task's address map. For shared // memory we add up all the pages that are marked as shared. Like libtop we // try to avoid counting pages that are also referenced by other tasks. Since // we don't have access to the VM regions of other tasks the only hint we have // is if the address is in the shared region area. // // Private memory is much simpler. We simply count the pages that are marked // as private or copy on write (COW). // // See libtop_update_vm_regions in // http://www.opensource.apple.com/source/top/top-67/libtop.c mach_vm_size_t size = 0; for (mach_vm_address_t address = MACH_VM_MIN_ADDRESS;; address += size) { vm_region_top_info_data_t info; mach_msg_type_number_t info_count = VM_REGION_TOP_INFO_COUNT; mach_port_t object_name; kern_return_t kr = mach_vm_region(task, &address, &size, VM_REGION_TOP_INFO, reinterpret_cast<vm_region_info_t>(&info), &info_count, &object_name); if (kr == KERN_INVALID_ADDRESS) { // We're at the end of the address space. break; } else if (kr != KERN_SUCCESS) { MACH_DLOG(ERROR, kr) << "mach_vm_region"; return false; } // The kernel always returns a null object for VM_REGION_TOP_INFO, but // balance it with a deallocate in case this ever changes. See 10.9.2 // xnu-2422.90.20/osfmk/vm/vm_map.c vm_map_region. mach_port_deallocate(mach_task_self(), object_name); if (IsAddressInSharedRegion(address, cpu_type) && info.share_mode != SM_PRIVATE) continue; if (info.share_mode == SM_COW && info.ref_count == 1) info.share_mode = SM_PRIVATE; switch (info.share_mode) { case SM_PRIVATE: private_pages_count += info.private_pages_resident; private_pages_count += info.shared_pages_resident; break; case SM_COW: private_pages_count += info.private_pages_resident; // Fall through case SM_SHARED: if (seen_objects.count(info.obj_id) == 0) { // Only count the first reference to this region. seen_objects.insert(info.obj_id); shared_pages_count += info.shared_pages_resident; } break; default: break; } } if (private_bytes) *private_bytes = private_pages_count * PAGE_SIZE; if (shared_bytes) *shared_bytes = shared_pages_count * PAGE_SIZE; return true; } void ProcessMetrics::GetCommittedKBytes(CommittedKBytes* usage) const { WorkingSetKBytes unused; if (!GetCommittedAndWorkingSetKBytes(usage, &unused)) { *usage = CommittedKBytes(); } } bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const { CommittedKBytes unused; return GetCommittedAndWorkingSetKBytes(&unused, ws_usage); } bool ProcessMetrics::GetCommittedAndWorkingSetKBytes( CommittedKBytes* usage, WorkingSetKBytes* ws_usage) const { task_basic_info_64 task_info_data; if (!GetTaskInfo(TaskForPid(process_), &task_info_data)) return false; usage->priv = task_info_data.virtual_size / 1024; usage->mapped = 0; usage->image = 0; ws_usage->priv = task_info_data.resident_size / 1024; ws_usage->shareable = 0; ws_usage->shared = 0; return true; } #define TIME_VALUE_TO_TIMEVAL(a, r) do { \ (r)->tv_sec = (a)->seconds; \ (r)->tv_usec = (a)->microseconds; \ } while (0) double ProcessMetrics::GetCPUUsage() { mach_port_t task = TaskForPid(process_); if (task == MACH_PORT_NULL) return 0; // Libtop explicitly loops over the threads (libtop_pinfo_update_cpu_usage() // in libtop.c), but this is more concise and gives the same results: task_thread_times_info thread_info_data; mach_msg_type_number_t thread_info_count = TASK_THREAD_TIMES_INFO_COUNT; kern_return_t kr = task_info(task, TASK_THREAD_TIMES_INFO, reinterpret_cast<task_info_t>(&thread_info_data), &thread_info_count); if (kr != KERN_SUCCESS) { // Most likely cause: |task| is a zombie. return 0; } task_basic_info_64 task_info_data; if (!GetTaskInfo(task, &task_info_data)) return 0; /* Set total_time. */ // thread info contains live time... struct timeval user_timeval, system_timeval, task_timeval; TIME_VALUE_TO_TIMEVAL(&thread_info_data.user_time, &user_timeval); TIME_VALUE_TO_TIMEVAL(&thread_info_data.system_time, &system_timeval); timeradd(&user_timeval, &system_timeval, &task_timeval); // ... task info contains terminated time. TIME_VALUE_TO_TIMEVAL(&task_info_data.user_time, &user_timeval); TIME_VALUE_TO_TIMEVAL(&task_info_data.system_time, &system_timeval); timeradd(&user_timeval, &task_timeval, &task_timeval); timeradd(&system_timeval, &task_timeval, &task_timeval); TimeTicks time = TimeTicks::Now(); int64_t task_time = TimeValToMicroseconds(task_timeval); if (last_system_time_ == 0) { // First call, just set the last values. last_cpu_time_ = time; last_system_time_ = task_time; return 0; } int64_t system_time_delta = task_time - last_system_time_; int64_t time_delta = (time - last_cpu_time_).InMicroseconds(); DCHECK_NE(0U, time_delta); if (time_delta == 0) return 0; last_cpu_time_ = time; last_system_time_ = task_time; return static_cast<double>(system_time_delta * 100.0) / time_delta; } int ProcessMetrics::GetIdleWakeupsPerSecond() { mach_port_t task = TaskForPid(process_); if (task == MACH_PORT_NULL) return 0; task_power_info power_info_data; mach_msg_type_number_t power_info_count = TASK_POWER_INFO_COUNT; kern_return_t kr = task_info(task, TASK_POWER_INFO, reinterpret_cast<task_info_t>(&power_info_data), &power_info_count); if (kr != KERN_SUCCESS) { // Most likely cause: |task| is a zombie, or this is on a pre-10.8.4 system // where TASK_POWER_INFO isn't supported yet. return 0; } return CalculateIdleWakeupsPerSecond( power_info_data.task_platform_idle_wakeups); } bool ProcessMetrics::GetIOCounters(IoCounters* /* io_counters */) const { return false; } ProcessMetrics::ProcessMetrics(ProcessHandle process, PortProvider* port_provider) : process_(process), last_system_time_(0), last_absolute_idle_wakeups_(0), port_provider_(port_provider) { processor_count_ = SysInfo::NumberOfProcessors(); } mach_port_t ProcessMetrics::TaskForPid(ProcessHandle /* process */) const { mach_port_t task = MACH_PORT_NULL; if (port_provider_) task = port_provider_->TaskForPid(process_); if (task == MACH_PORT_NULL && process_ == getpid()) task = mach_task_self(); return task; } // Bytes committed by the system. size_t GetSystemCommitCharge() { base::mac::ScopedMachSendRight host(mach_host_self()); mach_msg_type_number_t count = HOST_VM_INFO_COUNT; vm_statistics_data_t data; kern_return_t kr = host_statistics(host.get(), HOST_VM_INFO, reinterpret_cast<host_info_t>(&data), &count); if (kr != KERN_SUCCESS) { MACH_DLOG(WARNING, kr) << "host_statistics"; return 0; } return (data.active_count * PAGE_SIZE) / 1024; } // On Mac, We only get total memory and free memory from the system. bool GetSystemMemoryInfo(SystemMemoryInfoKB* meminfo) { struct host_basic_info hostinfo; mach_msg_type_number_t count = HOST_BASIC_INFO_COUNT; base::mac::ScopedMachSendRight host(mach_host_self()); int result = host_info(host.get(), HOST_BASIC_INFO, reinterpret_cast<host_info_t>(&hostinfo), &count); if (result != KERN_SUCCESS) return false; DCHECK_EQ(HOST_BASIC_INFO_COUNT, count); meminfo->total = static_cast<int>(hostinfo.max_mem / 1024); vm_statistics_data_t vm_info; count = HOST_VM_INFO_COUNT; if (host_statistics(host.get(), HOST_VM_INFO, reinterpret_cast<host_info_t>(&vm_info), &count) != KERN_SUCCESS) { return false; } meminfo->free = static_cast<int>( (vm_info.free_count - vm_info.speculative_count) * PAGE_SIZE / 1024); return true; } } // namespace base