base/process/process_metrics_mac.cc

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