1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "base/process/process_metrics.h" 6 7 #include <mach/mach.h> 8 #include <mach/mach_vm.h> 9 #include <mach/shared_region.h> 10 #include <stddef.h> 11 #include <stdint.h> 12 #include <sys/sysctl.h> 13 14 #include "base/containers/hash_tables.h" 15 #include "base/logging.h" 16 #include "base/mac/mach_logging.h" 17 #include "base/mac/scoped_mach_port.h" 18 #include "base/sys_info.h" 19 20 #if !defined(TASK_POWER_INFO) 21 // Doesn't exist in the 10.6 or 10.7 SDKs. 22 #define TASK_POWER_INFO 21 23 struct task_power_info { 24 uint64_t total_user; 25 uint64_t total_system; 26 uint64_t task_interrupt_wakeups; 27 uint64_t task_platform_idle_wakeups; 28 uint64_t task_timer_wakeups_bin_1; 29 uint64_t task_timer_wakeups_bin_2; 30 }; 31 typedef struct task_power_info task_power_info_data_t; 32 typedef struct task_power_info *task_power_info_t; 33 #define TASK_POWER_INFO_COUNT ((mach_msg_type_number_t) \ 34 (sizeof (task_power_info_data_t) / sizeof (natural_t))) 35 #endif 36 37 namespace base { 38 39 namespace { 40 41 bool GetTaskInfo(mach_port_t task, task_basic_info_64* task_info_data) { 42 if (task == MACH_PORT_NULL) 43 return false; 44 mach_msg_type_number_t count = TASK_BASIC_INFO_64_COUNT; 45 kern_return_t kr = task_info(task, 46 TASK_BASIC_INFO_64, 47 reinterpret_cast<task_info_t>(task_info_data), 48 &count); 49 // Most likely cause for failure: |task| is a zombie. 50 return kr == KERN_SUCCESS; 51 } 52 53 bool GetCPUTypeForProcess(pid_t /* pid */, cpu_type_t* cpu_type) { 54 size_t len = sizeof(*cpu_type); 55 int result = sysctlbyname("sysctl.proc_cputype", 56 cpu_type, 57 &len, 58 NULL, 59 0); 60 if (result != 0) { 61 DPLOG(ERROR) << "sysctlbyname(""sysctl.proc_cputype"")"; 62 return false; 63 } 64 65 return true; 66 } 67 68 bool IsAddressInSharedRegion(mach_vm_address_t addr, cpu_type_t type) { 69 if (type == CPU_TYPE_I386) { 70 return addr >= SHARED_REGION_BASE_I386 && 71 addr < (SHARED_REGION_BASE_I386 + SHARED_REGION_SIZE_I386); 72 } else if (type == CPU_TYPE_X86_64) { 73 return addr >= SHARED_REGION_BASE_X86_64 && 74 addr < (SHARED_REGION_BASE_X86_64 + SHARED_REGION_SIZE_X86_64); 75 } else { 76 return false; 77 } 78 } 79 80 } // namespace 81 82 SystemMemoryInfoKB::SystemMemoryInfoKB() { 83 total = 0; 84 free = 0; 85 } 86 87 SystemMemoryInfoKB::SystemMemoryInfoKB(const SystemMemoryInfoKB& other) = 88 default; 89 90 // Getting a mach task from a pid for another process requires permissions in 91 // general, so there doesn't really seem to be a way to do these (and spinning 92 // up ps to fetch each stats seems dangerous to put in a base api for anyone to 93 // call). Child processes ipc their port, so return something if available, 94 // otherwise return 0. 95 96 // static 97 ProcessMetrics* ProcessMetrics::CreateProcessMetrics( 98 ProcessHandle process, 99 PortProvider* port_provider) { 100 return new ProcessMetrics(process, port_provider); 101 } 102 103 size_t ProcessMetrics::GetPagefileUsage() const { 104 task_basic_info_64 task_info_data; 105 if (!GetTaskInfo(TaskForPid(process_), &task_info_data)) 106 return 0; 107 return task_info_data.virtual_size; 108 } 109 110 size_t ProcessMetrics::GetPeakPagefileUsage() const { 111 return 0; 112 } 113 114 size_t ProcessMetrics::GetWorkingSetSize() const { 115 task_basic_info_64 task_info_data; 116 if (!GetTaskInfo(TaskForPid(process_), &task_info_data)) 117 return 0; 118 return task_info_data.resident_size; 119 } 120 121 size_t ProcessMetrics::GetPeakWorkingSetSize() const { 122 return 0; 123 } 124 125 // This is a rough approximation of the algorithm that libtop uses. 126 // private_bytes is the size of private resident memory. 127 // shared_bytes is the size of shared resident memory. 128 bool ProcessMetrics::GetMemoryBytes(size_t* private_bytes, 129 size_t* shared_bytes) { 130 size_t private_pages_count = 0; 131 size_t shared_pages_count = 0; 132 133 if (!private_bytes && !shared_bytes) 134 return true; 135 136 mach_port_t task = TaskForPid(process_); 137 if (task == MACH_PORT_NULL) { 138 DLOG(ERROR) << "Invalid process"; 139 return false; 140 } 141 142 cpu_type_t cpu_type; 143 if (!GetCPUTypeForProcess(process_, &cpu_type)) 144 return false; 145 146 // The same region can be referenced multiple times. To avoid double counting 147 // we need to keep track of which regions we've already counted. 148 base::hash_set<int> seen_objects; 149 150 // We iterate through each VM region in the task's address map. For shared 151 // memory we add up all the pages that are marked as shared. Like libtop we 152 // try to avoid counting pages that are also referenced by other tasks. Since 153 // we don't have access to the VM regions of other tasks the only hint we have 154 // is if the address is in the shared region area. 155 // 156 // Private memory is much simpler. We simply count the pages that are marked 157 // as private or copy on write (COW). 158 // 159 // See libtop_update_vm_regions in 160 // http://www.opensource.apple.com/source/top/top-67/libtop.c 161 mach_vm_size_t size = 0; 162 for (mach_vm_address_t address = MACH_VM_MIN_ADDRESS;; address += size) { 163 vm_region_top_info_data_t info; 164 mach_msg_type_number_t info_count = VM_REGION_TOP_INFO_COUNT; 165 mach_port_t object_name; 166 kern_return_t kr = mach_vm_region(task, 167 &address, 168 &size, 169 VM_REGION_TOP_INFO, 170 reinterpret_cast<vm_region_info_t>(&info), 171 &info_count, 172 &object_name); 173 if (kr == KERN_INVALID_ADDRESS) { 174 // We're at the end of the address space. 175 break; 176 } else if (kr != KERN_SUCCESS) { 177 MACH_DLOG(ERROR, kr) << "mach_vm_region"; 178 return false; 179 } 180 181 // The kernel always returns a null object for VM_REGION_TOP_INFO, but 182 // balance it with a deallocate in case this ever changes. See 10.9.2 183 // xnu-2422.90.20/osfmk/vm/vm_map.c vm_map_region. 184 mach_port_deallocate(mach_task_self(), object_name); 185 186 if (IsAddressInSharedRegion(address, cpu_type) && 187 info.share_mode != SM_PRIVATE) 188 continue; 189 190 if (info.share_mode == SM_COW && info.ref_count == 1) 191 info.share_mode = SM_PRIVATE; 192 193 switch (info.share_mode) { 194 case SM_PRIVATE: 195 private_pages_count += info.private_pages_resident; 196 private_pages_count += info.shared_pages_resident; 197 break; 198 case SM_COW: 199 private_pages_count += info.private_pages_resident; 200 // Fall through 201 case SM_SHARED: 202 if (seen_objects.count(info.obj_id) == 0) { 203 // Only count the first reference to this region. 204 seen_objects.insert(info.obj_id); 205 shared_pages_count += info.shared_pages_resident; 206 } 207 break; 208 default: 209 break; 210 } 211 } 212 213 if (private_bytes) 214 *private_bytes = private_pages_count * PAGE_SIZE; 215 if (shared_bytes) 216 *shared_bytes = shared_pages_count * PAGE_SIZE; 217 218 return true; 219 } 220 221 void ProcessMetrics::GetCommittedKBytes(CommittedKBytes* usage) const { 222 WorkingSetKBytes unused; 223 if (!GetCommittedAndWorkingSetKBytes(usage, &unused)) { 224 *usage = CommittedKBytes(); 225 } 226 } 227 228 bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const { 229 CommittedKBytes unused; 230 return GetCommittedAndWorkingSetKBytes(&unused, ws_usage); 231 } 232 233 bool ProcessMetrics::GetCommittedAndWorkingSetKBytes( 234 CommittedKBytes* usage, 235 WorkingSetKBytes* ws_usage) const { 236 task_basic_info_64 task_info_data; 237 if (!GetTaskInfo(TaskForPid(process_), &task_info_data)) 238 return false; 239 240 usage->priv = task_info_data.virtual_size / 1024; 241 usage->mapped = 0; 242 usage->image = 0; 243 244 ws_usage->priv = task_info_data.resident_size / 1024; 245 ws_usage->shareable = 0; 246 ws_usage->shared = 0; 247 248 return true; 249 } 250 251 #define TIME_VALUE_TO_TIMEVAL(a, r) do { \ 252 (r)->tv_sec = (a)->seconds; \ 253 (r)->tv_usec = (a)->microseconds; \ 254 } while (0) 255 256 double ProcessMetrics::GetCPUUsage() { 257 mach_port_t task = TaskForPid(process_); 258 if (task == MACH_PORT_NULL) 259 return 0; 260 261 // Libtop explicitly loops over the threads (libtop_pinfo_update_cpu_usage() 262 // in libtop.c), but this is more concise and gives the same results: 263 task_thread_times_info thread_info_data; 264 mach_msg_type_number_t thread_info_count = TASK_THREAD_TIMES_INFO_COUNT; 265 kern_return_t kr = task_info(task, 266 TASK_THREAD_TIMES_INFO, 267 reinterpret_cast<task_info_t>(&thread_info_data), 268 &thread_info_count); 269 if (kr != KERN_SUCCESS) { 270 // Most likely cause: |task| is a zombie. 271 return 0; 272 } 273 274 task_basic_info_64 task_info_data; 275 if (!GetTaskInfo(task, &task_info_data)) 276 return 0; 277 278 /* Set total_time. */ 279 // thread info contains live time... 280 struct timeval user_timeval, system_timeval, task_timeval; 281 TIME_VALUE_TO_TIMEVAL(&thread_info_data.user_time, &user_timeval); 282 TIME_VALUE_TO_TIMEVAL(&thread_info_data.system_time, &system_timeval); 283 timeradd(&user_timeval, &system_timeval, &task_timeval); 284 285 // ... task info contains terminated time. 286 TIME_VALUE_TO_TIMEVAL(&task_info_data.user_time, &user_timeval); 287 TIME_VALUE_TO_TIMEVAL(&task_info_data.system_time, &system_timeval); 288 timeradd(&user_timeval, &task_timeval, &task_timeval); 289 timeradd(&system_timeval, &task_timeval, &task_timeval); 290 291 TimeTicks time = TimeTicks::Now(); 292 int64_t task_time = TimeValToMicroseconds(task_timeval); 293 294 if (last_system_time_ == 0) { 295 // First call, just set the last values. 296 last_cpu_time_ = time; 297 last_system_time_ = task_time; 298 return 0; 299 } 300 301 int64_t system_time_delta = task_time - last_system_time_; 302 int64_t time_delta = (time - last_cpu_time_).InMicroseconds(); 303 DCHECK_NE(0U, time_delta); 304 if (time_delta == 0) 305 return 0; 306 307 last_cpu_time_ = time; 308 last_system_time_ = task_time; 309 310 return static_cast<double>(system_time_delta * 100.0) / time_delta; 311 } 312 313 int ProcessMetrics::GetIdleWakeupsPerSecond() { 314 mach_port_t task = TaskForPid(process_); 315 if (task == MACH_PORT_NULL) 316 return 0; 317 318 task_power_info power_info_data; 319 mach_msg_type_number_t power_info_count = TASK_POWER_INFO_COUNT; 320 kern_return_t kr = task_info(task, 321 TASK_POWER_INFO, 322 reinterpret_cast<task_info_t>(&power_info_data), 323 &power_info_count); 324 if (kr != KERN_SUCCESS) { 325 // Most likely cause: |task| is a zombie, or this is on a pre-10.8.4 system 326 // where TASK_POWER_INFO isn't supported yet. 327 return 0; 328 } 329 return CalculateIdleWakeupsPerSecond( 330 power_info_data.task_platform_idle_wakeups); 331 } 332 333 bool ProcessMetrics::GetIOCounters(IoCounters* /* io_counters */) const { 334 return false; 335 } 336 337 ProcessMetrics::ProcessMetrics(ProcessHandle process, 338 PortProvider* port_provider) 339 : process_(process), 340 last_system_time_(0), 341 last_absolute_idle_wakeups_(0), 342 port_provider_(port_provider) { 343 processor_count_ = SysInfo::NumberOfProcessors(); 344 } 345 346 mach_port_t ProcessMetrics::TaskForPid(ProcessHandle /* process */) const { 347 mach_port_t task = MACH_PORT_NULL; 348 if (port_provider_) 349 task = port_provider_->TaskForPid(process_); 350 if (task == MACH_PORT_NULL && process_ == getpid()) 351 task = mach_task_self(); 352 return task; 353 } 354 355 // Bytes committed by the system. 356 size_t GetSystemCommitCharge() { 357 base::mac::ScopedMachSendRight host(mach_host_self()); 358 mach_msg_type_number_t count = HOST_VM_INFO_COUNT; 359 vm_statistics_data_t data; 360 kern_return_t kr = host_statistics(host.get(), HOST_VM_INFO, 361 reinterpret_cast<host_info_t>(&data), 362 &count); 363 if (kr != KERN_SUCCESS) { 364 MACH_DLOG(WARNING, kr) << "host_statistics"; 365 return 0; 366 } 367 368 return (data.active_count * PAGE_SIZE) / 1024; 369 } 370 371 // On Mac, We only get total memory and free memory from the system. 372 bool GetSystemMemoryInfo(SystemMemoryInfoKB* meminfo) { 373 struct host_basic_info hostinfo; 374 mach_msg_type_number_t count = HOST_BASIC_INFO_COUNT; 375 base::mac::ScopedMachSendRight host(mach_host_self()); 376 int result = host_info(host.get(), HOST_BASIC_INFO, 377 reinterpret_cast<host_info_t>(&hostinfo), &count); 378 if (result != KERN_SUCCESS) 379 return false; 380 381 DCHECK_EQ(HOST_BASIC_INFO_COUNT, count); 382 meminfo->total = static_cast<int>(hostinfo.max_mem / 1024); 383 384 vm_statistics_data_t vm_info; 385 count = HOST_VM_INFO_COUNT; 386 387 if (host_statistics(host.get(), HOST_VM_INFO, 388 reinterpret_cast<host_info_t>(&vm_info), 389 &count) != KERN_SUCCESS) { 390 return false; 391 } 392 393 meminfo->free = static_cast<int>( 394 (vm_info.free_count - vm_info.speculative_count) * PAGE_SIZE / 1024); 395 396 return true; 397 } 398 399 } // namespace base 400