process_metrics_mac.cc revision 90dce4d38c5ff5333bea97d859d4e484e27edf0c 
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/hash_tables.h"
13#include "base/logging.h"
14#include "base/mac/scoped_mach_port.h"
15#include "base/sys_info.h"
16
17namespace base {
18
19namespace {
20
21bool 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
33bool 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
48bool 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
69ProcessMetrics* ProcessMetrics::CreateProcessMetrics(
70    ProcessHandle process,
71    ProcessMetrics::PortProvider* port_provider) {
72  return new ProcessMetrics(process, port_provider);
73}
74
75size_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
82size_t ProcessMetrics::GetPeakPagefileUsage() const {
83  return 0;
84}
85
86size_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
93size_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.
100bool 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
198void ProcessMetrics::GetCommittedKBytes(CommittedKBytes* usage) const {
199}
200
201bool 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
216double 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
280bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const {
281  return false;
282}
283
284ProcessMetrics::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
293mach_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.
303size_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
326