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