process_metrics_linux.cc revision 0f1bc08d4cfcc34181b0b5cbf065c40f687bf740
1cf2cfa174ca878c144e17e9fc60ca8e9070d7dededisonn@google.com// Copyright (c) 2013 The Chromium Authors. All rights reserved. 2cf2cfa174ca878c144e17e9fc60ca8e9070d7dededisonn@google.com// Use of this source code is governed by a BSD-style license that can be 38cee797901763ab0922eb9ef484cfdcbc94bee54edisonn@google.com// found in the LICENSE file. 4cf2cfa174ca878c144e17e9fc60ca8e9070d7dededisonn@google.com 5cf2cfa174ca878c144e17e9fc60ca8e9070d7dededisonn@google.com#include "base/process/process_metrics.h" 6cf2cfa174ca878c144e17e9fc60ca8e9070d7dededisonn@google.com 78cee797901763ab0922eb9ef484cfdcbc94bee54edisonn@google.com#include <dirent.h> 8cf2cfa174ca878c144e17e9fc60ca8e9070d7dededisonn@google.com#include <fcntl.h> 98cee797901763ab0922eb9ef484cfdcbc94bee54edisonn@google.com#include <sys/stat.h> 10cf2cfa174ca878c144e17e9fc60ca8e9070d7dededisonn@google.com#include <sys/time.h> 118cee797901763ab0922eb9ef484cfdcbc94bee54edisonn@google.com#include <sys/types.h> 128cee797901763ab0922eb9ef484cfdcbc94bee54edisonn@google.com#include <unistd.h> 138cee797901763ab0922eb9ef484cfdcbc94bee54edisonn@google.com 148cee797901763ab0922eb9ef484cfdcbc94bee54edisonn@google.com#include "base/file_util.h" 158cee797901763ab0922eb9ef484cfdcbc94bee54edisonn@google.com#include "base/logging.h" 168cee797901763ab0922eb9ef484cfdcbc94bee54edisonn@google.com#include "base/process/internal_linux.h" 178cee797901763ab0922eb9ef484cfdcbc94bee54edisonn@google.com#include "base/strings/string_number_conversions.h" 188cee797901763ab0922eb9ef484cfdcbc94bee54edisonn@google.com#include "base/strings/string_split.h" 198cee797901763ab0922eb9ef484cfdcbc94bee54edisonn@google.com#include "base/strings/string_tokenizer.h" 208cee797901763ab0922eb9ef484cfdcbc94bee54edisonn@google.com#include "base/strings/string_util.h" 218cee797901763ab0922eb9ef484cfdcbc94bee54edisonn@google.com#include "base/sys_info.h" 22#include "base/threading/thread_restrictions.h" 23 24namespace base { 25 26namespace { 27 28enum ParsingState { 29 KEY_NAME, 30 KEY_VALUE 31}; 32 33#ifdef OS_CHROMEOS 34// Read a file with a single number string and return the number as a uint64. 35static uint64 ReadFileToUint64(const base::FilePath file) { 36 std::string file_as_string; 37 if (!ReadFileToString(file, &file_as_string)) 38 return 0; 39 TrimWhitespaceASCII(file_as_string, TRIM_ALL, &file_as_string); 40 uint64 file_as_uint64 = 0; 41 if (!base::StringToUint64(file_as_string, &file_as_uint64)) 42 return 0; 43 return file_as_uint64; 44} 45#endif 46 47// Read /proc/<pid>/status and returns the value for |field|, or 0 on failure. 48// Only works for fields in the form of "Field: value kB". 49size_t ReadProcStatusAndGetFieldAsSizeT(pid_t pid, const std::string& field) { 50 FilePath stat_file = internal::GetProcPidDir(pid).Append("status"); 51 std::string status; 52 { 53 // Synchronously reading files in /proc is safe. 54 ThreadRestrictions::ScopedAllowIO allow_io; 55 if (!ReadFileToString(stat_file, &status)) 56 return 0; 57 } 58 59 StringTokenizer tokenizer(status, ":\n"); 60 ParsingState state = KEY_NAME; 61 StringPiece last_key_name; 62 while (tokenizer.GetNext()) { 63 switch (state) { 64 case KEY_NAME: 65 last_key_name = tokenizer.token_piece(); 66 state = KEY_VALUE; 67 break; 68 case KEY_VALUE: 69 DCHECK(!last_key_name.empty()); 70 if (last_key_name == field) { 71 std::string value_str; 72 tokenizer.token_piece().CopyToString(&value_str); 73 std::string value_str_trimmed; 74 TrimWhitespaceASCII(value_str, TRIM_ALL, &value_str_trimmed); 75 std::vector<std::string> split_value_str; 76 SplitString(value_str_trimmed, ' ', &split_value_str); 77 if (split_value_str.size() != 2 || split_value_str[1] != "kB") { 78 NOTREACHED(); 79 return 0; 80 } 81 size_t value; 82 if (!StringToSizeT(split_value_str[0], &value)) { 83 NOTREACHED(); 84 return 0; 85 } 86 return value; 87 } 88 state = KEY_NAME; 89 break; 90 } 91 } 92 NOTREACHED(); 93 return 0; 94} 95 96// Get the total CPU of a single process. Return value is number of jiffies 97// on success or -1 on error. 98int GetProcessCPU(pid_t pid) { 99 // Use /proc/<pid>/task to find all threads and parse their /stat file. 100 FilePath task_path = internal::GetProcPidDir(pid).Append("task"); 101 102 DIR* dir = opendir(task_path.value().c_str()); 103 if (!dir) { 104 DPLOG(ERROR) << "opendir(" << task_path.value() << ")"; 105 return -1; 106 } 107 108 int total_cpu = 0; 109 while (struct dirent* ent = readdir(dir)) { 110 pid_t tid = internal::ProcDirSlotToPid(ent->d_name); 111 if (!tid) 112 continue; 113 114 // Synchronously reading files in /proc is safe. 115 ThreadRestrictions::ScopedAllowIO allow_io; 116 117 std::string stat; 118 FilePath stat_path = 119 task_path.Append(ent->d_name).Append(internal::kStatFile); 120 if (ReadFileToString(stat_path, &stat)) { 121 int cpu = ParseProcStatCPU(stat); 122 if (cpu > 0) 123 total_cpu += cpu; 124 } 125 } 126 closedir(dir); 127 128 return total_cpu; 129} 130 131} // namespace 132 133// static 134ProcessMetrics* ProcessMetrics::CreateProcessMetrics(ProcessHandle process) { 135 return new ProcessMetrics(process); 136} 137 138// On linux, we return vsize. 139size_t ProcessMetrics::GetPagefileUsage() const { 140 return internal::ReadProcStatsAndGetFieldAsSizeT(process_, 141 internal::VM_VSIZE); 142} 143 144// On linux, we return the high water mark of vsize. 145size_t ProcessMetrics::GetPeakPagefileUsage() const { 146 return ReadProcStatusAndGetFieldAsSizeT(process_, "VmPeak") * 1024; 147} 148 149// On linux, we return RSS. 150size_t ProcessMetrics::GetWorkingSetSize() const { 151 return internal::ReadProcStatsAndGetFieldAsSizeT(process_, internal::VM_RSS) * 152 getpagesize(); 153} 154 155// On linux, we return the high water mark of RSS. 156size_t ProcessMetrics::GetPeakWorkingSetSize() const { 157 return ReadProcStatusAndGetFieldAsSizeT(process_, "VmHWM") * 1024; 158} 159 160bool ProcessMetrics::GetMemoryBytes(size_t* private_bytes, 161 size_t* shared_bytes) { 162 WorkingSetKBytes ws_usage; 163 if (!GetWorkingSetKBytes(&ws_usage)) 164 return false; 165 166 if (private_bytes) 167 *private_bytes = ws_usage.priv * 1024; 168 169 if (shared_bytes) 170 *shared_bytes = ws_usage.shared * 1024; 171 172 return true; 173} 174 175bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const { 176#if defined(OS_CHROMEOS) 177 if (GetWorkingSetKBytesTotmaps(ws_usage)) 178 return true; 179#endif 180 return GetWorkingSetKBytesStatm(ws_usage); 181} 182 183double ProcessMetrics::GetCPUUsage() { 184 struct timeval now; 185 int retval = gettimeofday(&now, NULL); 186 if (retval) 187 return 0; 188 int64 time = TimeValToMicroseconds(now); 189 190 if (last_time_ == 0) { 191 // First call, just set the last values. 192 last_time_ = time; 193 last_cpu_ = GetProcessCPU(process_); 194 return 0; 195 } 196 197 int64 time_delta = time - last_time_; 198 DCHECK_NE(time_delta, 0); 199 if (time_delta == 0) 200 return 0; 201 202 int cpu = GetProcessCPU(process_); 203 204 // We have the number of jiffies in the time period. Convert to percentage. 205 // Note this means we will go *over* 100 in the case where multiple threads 206 // are together adding to more than one CPU's worth. 207 TimeDelta cpu_time = internal::ClockTicksToTimeDelta(cpu); 208 TimeDelta last_cpu_time = internal::ClockTicksToTimeDelta(last_cpu_); 209 int percentage = 100 * (cpu_time - last_cpu_time).InSecondsF() / 210 TimeDelta::FromMicroseconds(time_delta).InSecondsF(); 211 212 last_time_ = time; 213 last_cpu_ = cpu; 214 215 return percentage; 216} 217 218// To have /proc/self/io file you must enable CONFIG_TASK_IO_ACCOUNTING 219// in your kernel configuration. 220bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const { 221 // Synchronously reading files in /proc is safe. 222 ThreadRestrictions::ScopedAllowIO allow_io; 223 224 std::string proc_io_contents; 225 FilePath io_file = internal::GetProcPidDir(process_).Append("io"); 226 if (!ReadFileToString(io_file, &proc_io_contents)) 227 return false; 228 229 (*io_counters).OtherOperationCount = 0; 230 (*io_counters).OtherTransferCount = 0; 231 232 StringTokenizer tokenizer(proc_io_contents, ": \n"); 233 ParsingState state = KEY_NAME; 234 StringPiece last_key_name; 235 while (tokenizer.GetNext()) { 236 switch (state) { 237 case KEY_NAME: 238 last_key_name = tokenizer.token_piece(); 239 state = KEY_VALUE; 240 break; 241 case KEY_VALUE: 242 DCHECK(!last_key_name.empty()); 243 if (last_key_name == "syscr") { 244 StringToInt64(tokenizer.token_piece(), 245 reinterpret_cast<int64*>(&(*io_counters).ReadOperationCount)); 246 } else if (last_key_name == "syscw") { 247 StringToInt64(tokenizer.token_piece(), 248 reinterpret_cast<int64*>(&(*io_counters).WriteOperationCount)); 249 } else if (last_key_name == "rchar") { 250 StringToInt64(tokenizer.token_piece(), 251 reinterpret_cast<int64*>(&(*io_counters).ReadTransferCount)); 252 } else if (last_key_name == "wchar") { 253 StringToInt64(tokenizer.token_piece(), 254 reinterpret_cast<int64*>(&(*io_counters).WriteTransferCount)); 255 } 256 state = KEY_NAME; 257 break; 258 } 259 } 260 return true; 261} 262 263ProcessMetrics::ProcessMetrics(ProcessHandle process) 264 : process_(process), 265 last_time_(0), 266 last_system_time_(0), 267 last_cpu_(0) { 268 processor_count_ = base::SysInfo::NumberOfProcessors(); 269} 270 271#if defined(OS_CHROMEOS) 272// Private, Shared and Proportional working set sizes are obtained from 273// /proc/<pid>/totmaps 274bool ProcessMetrics::GetWorkingSetKBytesTotmaps(WorkingSetKBytes *ws_usage) 275 const { 276 // The format of /proc/<pid>/totmaps is: 277 // 278 // Rss: 6120 kB 279 // Pss: 3335 kB 280 // Shared_Clean: 1008 kB 281 // Shared_Dirty: 4012 kB 282 // Private_Clean: 4 kB 283 // Private_Dirty: 1096 kB 284 // Referenced: XXX kB 285 // Anonymous: XXX kB 286 // AnonHugePages: XXX kB 287 // Swap: XXX kB 288 // Locked: XXX kB 289 const size_t kPssIndex = (1 * 3) + 1; 290 const size_t kPrivate_CleanIndex = (4 * 3) + 1; 291 const size_t kPrivate_DirtyIndex = (5 * 3) + 1; 292 const size_t kSwapIndex = (9 * 3) + 1; 293 294 std::string totmaps_data; 295 { 296 FilePath totmaps_file = internal::GetProcPidDir(process_).Append("totmaps"); 297 ThreadRestrictions::ScopedAllowIO allow_io; 298 bool ret = ReadFileToString(totmaps_file, &totmaps_data); 299 if (!ret || totmaps_data.length() == 0) 300 return false; 301 } 302 303 std::vector<std::string> totmaps_fields; 304 SplitStringAlongWhitespace(totmaps_data, &totmaps_fields); 305 306 DCHECK_EQ("Pss:", totmaps_fields[kPssIndex-1]); 307 DCHECK_EQ("Private_Clean:", totmaps_fields[kPrivate_CleanIndex - 1]); 308 DCHECK_EQ("Private_Dirty:", totmaps_fields[kPrivate_DirtyIndex - 1]); 309 DCHECK_EQ("Swap:", totmaps_fields[kSwapIndex-1]); 310 311 int pss = 0; 312 int private_clean = 0; 313 int private_dirty = 0; 314 int swap = 0; 315 bool ret = true; 316 ret &= StringToInt(totmaps_fields[kPssIndex], &pss); 317 ret &= StringToInt(totmaps_fields[kPrivate_CleanIndex], &private_clean); 318 ret &= StringToInt(totmaps_fields[kPrivate_DirtyIndex], &private_dirty); 319 ret &= StringToInt(totmaps_fields[kSwapIndex], &swap); 320 321 // On ChromeOS swap is to zram. We count this as private / shared, as 322 // increased swap decreases available RAM to user processes, which would 323 // otherwise create surprising results. 324 ws_usage->priv = private_clean + private_dirty + swap; 325 ws_usage->shared = pss + swap; 326 ws_usage->shareable = 0; 327 ws_usage->swapped = swap; 328 return ret; 329} 330#endif 331 332// Private and Shared working set sizes are obtained from /proc/<pid>/statm. 333bool ProcessMetrics::GetWorkingSetKBytesStatm(WorkingSetKBytes* ws_usage) 334 const { 335 // Use statm instead of smaps because smaps is: 336 // a) Large and slow to parse. 337 // b) Unavailable in the SUID sandbox. 338 339 // First we need to get the page size, since everything is measured in pages. 340 // For details, see: man 5 proc. 341 const int page_size_kb = getpagesize() / 1024; 342 if (page_size_kb <= 0) 343 return false; 344 345 std::string statm; 346 { 347 FilePath statm_file = internal::GetProcPidDir(process_).Append("statm"); 348 // Synchronously reading files in /proc is safe. 349 ThreadRestrictions::ScopedAllowIO allow_io; 350 bool ret = ReadFileToString(statm_file, &statm); 351 if (!ret || statm.length() == 0) 352 return false; 353 } 354 355 std::vector<std::string> statm_vec; 356 SplitString(statm, ' ', &statm_vec); 357 if (statm_vec.size() != 7) 358 return false; // Not the format we expect. 359 360 int statm_rss, statm_shared; 361 bool ret = true; 362 ret &= StringToInt(statm_vec[1], &statm_rss); 363 ret &= StringToInt(statm_vec[2], &statm_shared); 364 365 ws_usage->priv = (statm_rss - statm_shared) * page_size_kb; 366 ws_usage->shared = statm_shared * page_size_kb; 367 368 // Sharable is not calculated, as it does not provide interesting data. 369 ws_usage->shareable = 0; 370 371#if defined(OS_CHROMEOS) 372 // Can't get swapped memory from statm. 373 ws_usage->swapped = 0; 374#endif 375 376 return ret; 377} 378 379size_t GetSystemCommitCharge() { 380 SystemMemoryInfoKB meminfo; 381 if (!GetSystemMemoryInfo(&meminfo)) 382 return 0; 383 return meminfo.total - meminfo.free - meminfo.buffers - meminfo.cached; 384} 385 386// Exposed for testing. 387int ParseProcStatCPU(const std::string& input) { 388 std::vector<std::string> proc_stats; 389 if (!internal::ParseProcStats(input, &proc_stats)) 390 return -1; 391 392 if (proc_stats.size() <= internal::VM_STIME) 393 return -1; 394 int utime = GetProcStatsFieldAsInt(proc_stats, internal::VM_UTIME); 395 int stime = GetProcStatsFieldAsInt(proc_stats, internal::VM_STIME); 396 return utime + stime; 397} 398 399const char kProcSelfExe[] = "/proc/self/exe"; 400 401int GetNumberOfThreads(ProcessHandle process) { 402 return internal::ReadProcStatsAndGetFieldAsInt(process, 403 internal::VM_NUMTHREADS); 404} 405 406namespace { 407 408// The format of /proc/meminfo is: 409// 410// MemTotal: 8235324 kB 411// MemFree: 1628304 kB 412// Buffers: 429596 kB 413// Cached: 4728232 kB 414// ... 415const size_t kMemTotalIndex = 1; 416const size_t kMemFreeIndex = 4; 417const size_t kMemBuffersIndex = 7; 418const size_t kMemCachedIndex = 10; 419const size_t kMemActiveAnonIndex = 22; 420const size_t kMemInactiveAnonIndex = 25; 421const size_t kMemActiveFileIndex = 28; 422const size_t kMemInactiveFileIndex = 31; 423 424// The format of /proc/vmstat is: 425// 426// nr_free_pages 299878 427// nr_inactive_anon 239863 428// nr_active_anon 1318966 429// nr_inactive_file 2015629 430// ... 431const size_t kVMPagesSwappedIn = 75; 432const size_t kVMPagesSwappedOut = 77; 433const size_t kVMPageMajorFaults = 95; 434 435// The format of /proc/diskstats is: 436// Device major number 437// Device minor number 438// Device name 439// Field 1 -- # of reads completed 440// This is the total number of reads completed successfully. 441// Field 2 -- # of reads merged, field 6 -- # of writes merged 442// Reads and writes which are adjacent to each other may be merged for 443// efficiency. Thus two 4K reads may become one 8K read before it is 444// ultimately handed to the disk, and so it will be counted (and queued) 445// as only one I/O. This field lets you know how often this was done. 446// Field 3 -- # of sectors read 447// This is the total number of sectors read successfully. 448// Field 4 -- # of milliseconds spent reading 449// This is the total number of milliseconds spent by all reads (as 450// measured from __make_request() to end_that_request_last()). 451// Field 5 -- # of writes completed 452// This is the total number of writes completed successfully. 453// Field 6 -- # of writes merged 454// See the description of field 2. 455// Field 7 -- # of sectors written 456// This is the total number of sectors written successfully. 457// Field 8 -- # of milliseconds spent writing 458// This is the total number of milliseconds spent by all writes (as 459// measured from __make_request() to end_that_request_last()). 460// Field 9 -- # of I/Os currently in progress 461// The only field that should go to zero. Incremented as requests are 462// given to appropriate struct request_queue and decremented as they 463// finish. 464// Field 10 -- # of milliseconds spent doing I/Os 465// This field increases so long as field 9 is nonzero. 466// Field 11 -- weighted # of milliseconds spent doing I/Os 467// This field is incremented at each I/O start, I/O completion, I/O 468// merge, or read of these stats by the number of I/Os in progress 469// (field 9) times the number of milliseconds spent doing I/O since the 470// last update of this field. This can provide an easy measure of both 471// I/O completion time and the backlog that may be accumulating. 472 473const size_t kDiskDriveName = 2; 474const size_t kDiskReads = 3; 475const size_t kDiskReadsMerged = 4; 476const size_t kDiskSectorsRead = 5; 477const size_t kDiskReadTime = 6; 478const size_t kDiskWrites = 7; 479const size_t kDiskWritesMerged = 8; 480const size_t kDiskSectorsWritten = 9; 481const size_t kDiskWriteTime = 10; 482const size_t kDiskIO = 11; 483const size_t kDiskIOTime = 12; 484const size_t kDiskWeightedIOTime = 13; 485 486} // namespace 487 488SystemMemoryInfoKB::SystemMemoryInfoKB() { 489 total = 0; 490 free = 0; 491 buffers = 0; 492 cached = 0; 493 active_anon = 0; 494 inactive_anon = 0; 495 active_file = 0; 496 inactive_file = 0; 497 swap_total = 0; 498 swap_free = 0; 499 dirty = 0; 500 501 pswpin = 0; 502 pswpout = 0; 503 pgmajfault = 0; 504 505#ifdef OS_CHROMEOS 506 shmem = 0; 507 slab = 0; 508 gem_objects = -1; 509 gem_size = -1; 510#endif 511} 512 513scoped_ptr<Value> SystemMemoryInfoKB::ToValue() const { 514 scoped_ptr<DictionaryValue> res(new base::DictionaryValue()); 515 516 res->SetInteger("total", total); 517 res->SetInteger("free", free); 518 res->SetInteger("buffers", buffers); 519 res->SetInteger("cached", cached); 520 res->SetInteger("active_anon", active_anon); 521 res->SetInteger("inactive_anon", inactive_anon); 522 res->SetInteger("active_file", active_file); 523 res->SetInteger("inactive_file", inactive_file); 524 res->SetInteger("swap_total", swap_total); 525 res->SetInteger("swap_free", swap_free); 526 res->SetInteger("swap_used", swap_total - swap_free); 527 res->SetInteger("dirty", dirty); 528 res->SetInteger("pswpin", pswpin); 529 res->SetInteger("pswpout", pswpout); 530 res->SetInteger("pgmajfault", pgmajfault); 531#ifdef OS_CHROMEOS 532 res->SetInteger("shmem", shmem); 533 res->SetInteger("slab", slab); 534 res->SetInteger("gem_objects", gem_objects); 535 res->SetInteger("gem_size", gem_size); 536#endif 537 538 return res.PassAs<Value>(); 539} 540 541// exposed for testing 542bool ParseProcMeminfo(const std::string& meminfo_data, 543 SystemMemoryInfoKB* meminfo) { 544 std::vector<std::string> meminfo_fields; 545 SplitStringAlongWhitespace(meminfo_data, &meminfo_fields); 546 547 if (meminfo_fields.size() < kMemCachedIndex) { 548 return false; 549 } 550 551 DCHECK_EQ(meminfo_fields[kMemTotalIndex-1], "MemTotal:"); 552 DCHECK_EQ(meminfo_fields[kMemFreeIndex-1], "MemFree:"); 553 DCHECK_EQ(meminfo_fields[kMemBuffersIndex-1], "Buffers:"); 554 DCHECK_EQ(meminfo_fields[kMemCachedIndex-1], "Cached:"); 555 DCHECK_EQ(meminfo_fields[kMemActiveAnonIndex-1], "Active(anon):"); 556 DCHECK_EQ(meminfo_fields[kMemInactiveAnonIndex-1], "Inactive(anon):"); 557 DCHECK_EQ(meminfo_fields[kMemActiveFileIndex-1], "Active(file):"); 558 DCHECK_EQ(meminfo_fields[kMemInactiveFileIndex-1], "Inactive(file):"); 559 560 StringToInt(meminfo_fields[kMemTotalIndex], &meminfo->total); 561 StringToInt(meminfo_fields[kMemFreeIndex], &meminfo->free); 562 StringToInt(meminfo_fields[kMemBuffersIndex], &meminfo->buffers); 563 StringToInt(meminfo_fields[kMemCachedIndex], &meminfo->cached); 564 StringToInt(meminfo_fields[kMemActiveAnonIndex], &meminfo->active_anon); 565 StringToInt(meminfo_fields[kMemInactiveAnonIndex], &meminfo->inactive_anon); 566 StringToInt(meminfo_fields[kMemActiveFileIndex], &meminfo->active_file); 567 StringToInt(meminfo_fields[kMemInactiveFileIndex], &meminfo->inactive_file); 568 569 // We don't know when these fields appear, so we must search for them. 570 for (size_t i = kMemCachedIndex+2; i < meminfo_fields.size(); i += 3) { 571 if (meminfo_fields[i] == "SwapTotal:") 572 StringToInt(meminfo_fields[i+1], &meminfo->swap_total); 573 if (meminfo_fields[i] == "SwapFree:") 574 StringToInt(meminfo_fields[i+1], &meminfo->swap_free); 575 if (meminfo_fields[i] == "Dirty:") 576 StringToInt(meminfo_fields[i+1], &meminfo->dirty); 577 } 578 579#if defined(OS_CHROMEOS) 580 // Chrome OS has a tweaked kernel that allows us to query Shmem, which is 581 // usually video memory otherwise invisible to the OS. Unfortunately, the 582 // meminfo format varies on different hardware so we have to search for the 583 // string. It always appears after "Cached:". 584 for (size_t i = kMemCachedIndex+2; i < meminfo_fields.size(); i += 3) { 585 if (meminfo_fields[i] == "Shmem:") 586 StringToInt(meminfo_fields[i+1], &meminfo->shmem); 587 if (meminfo_fields[i] == "Slab:") 588 StringToInt(meminfo_fields[i+1], &meminfo->slab); 589 } 590#endif 591 592 return true; 593} 594 595// exposed for testing 596bool ParseProcVmstat(const std::string& vmstat_data, 597 SystemMemoryInfoKB* meminfo) { 598 std::vector<std::string> vmstat_fields; 599 SplitStringAlongWhitespace(vmstat_data, &vmstat_fields); 600 if (vmstat_fields[kVMPagesSwappedIn-1] == "pswpin") 601 StringToInt(vmstat_fields[kVMPagesSwappedIn], &meminfo->pswpin); 602 if (vmstat_fields[kVMPagesSwappedOut-1] == "pswpout") 603 StringToInt(vmstat_fields[kVMPagesSwappedOut], &meminfo->pswpout); 604 if (vmstat_fields[kVMPageMajorFaults-1] == "pgmajfault") 605 StringToInt(vmstat_fields[kVMPageMajorFaults], &meminfo->pgmajfault); 606 607 return true; 608} 609 610bool GetSystemMemoryInfo(SystemMemoryInfoKB* meminfo) { 611 // Synchronously reading files in /proc is safe. 612 ThreadRestrictions::ScopedAllowIO allow_io; 613 614 // Used memory is: total - free - buffers - caches 615 FilePath meminfo_file("/proc/meminfo"); 616 std::string meminfo_data; 617 if (!ReadFileToString(meminfo_file, &meminfo_data)) { 618 DLOG(WARNING) << "Failed to open " << meminfo_file.value(); 619 return false; 620 } 621 622 if (!ParseProcMeminfo(meminfo_data, meminfo)) { 623 DLOG(WARNING) << "Failed to parse " << meminfo_file.value(); 624 return false; 625 } 626 627#if defined(OS_CHROMEOS) 628 // Report on Chrome OS GEM object graphics memory. /var/run/debugfs_gpu is a 629 // bind mount into /sys/kernel/debug and synchronously reading the in-memory 630 // files in /sys is fast. 631#if defined(ARCH_CPU_ARM_FAMILY) 632 FilePath geminfo_file("/var/run/debugfs_gpu/exynos_gem_objects"); 633#else 634 FilePath geminfo_file("/var/run/debugfs_gpu/i915_gem_objects"); 635#endif 636 std::string geminfo_data; 637 meminfo->gem_objects = -1; 638 meminfo->gem_size = -1; 639 if (ReadFileToString(geminfo_file, &geminfo_data)) { 640 int gem_objects = -1; 641 long long gem_size = -1; 642 int num_res = sscanf(geminfo_data.c_str(), 643 "%d objects, %lld bytes", 644 &gem_objects, &gem_size); 645 if (num_res == 2) { 646 meminfo->gem_objects = gem_objects; 647 meminfo->gem_size = gem_size; 648 } 649 } 650 651#if defined(ARCH_CPU_ARM_FAMILY) 652 // Incorporate Mali graphics memory if present. 653 FilePath mali_memory_file("/sys/class/misc/mali0/device/memory"); 654 std::string mali_memory_data; 655 if (ReadFileToString(mali_memory_file, &mali_memory_data)) { 656 long long mali_size = -1; 657 int num_res = sscanf(mali_memory_data.c_str(), "%lld bytes", &mali_size); 658 if (num_res == 1) 659 meminfo->gem_size += mali_size; 660 } 661#endif // defined(ARCH_CPU_ARM_FAMILY) 662#endif // defined(OS_CHROMEOS) 663 664 FilePath vmstat_file("/proc/vmstat"); 665 std::string vmstat_data; 666 if (!ReadFileToString(vmstat_file, &vmstat_data)) { 667 DLOG(WARNING) << "Failed to open " << vmstat_file.value(); 668 return false; 669 } 670 if (!ParseProcVmstat(vmstat_data, meminfo)) { 671 DLOG(WARNING) << "Failed to parse " << vmstat_file.value(); 672 return false; 673 } 674 675 return true; 676} 677 678SystemDiskInfo::SystemDiskInfo() { 679 reads = 0; 680 reads_merged = 0; 681 sectors_read = 0; 682 read_time = 0; 683 writes = 0; 684 writes_merged = 0; 685 sectors_written = 0; 686 write_time = 0; 687 io = 0; 688 io_time = 0; 689 weighted_io_time = 0; 690} 691 692scoped_ptr<Value> SystemDiskInfo::ToValue() const { 693 scoped_ptr<DictionaryValue> res(new base::DictionaryValue()); 694 695 // Write out uint64 variables as doubles. 696 // Note: this may discard some precision, but for JS there's no other option. 697 res->SetDouble("reads", static_cast<double>(reads)); 698 res->SetDouble("reads_merged", static_cast<double>(reads_merged)); 699 res->SetDouble("sectors_read", static_cast<double>(sectors_read)); 700 res->SetDouble("read_time", static_cast<double>(read_time)); 701 res->SetDouble("writes", static_cast<double>(writes)); 702 res->SetDouble("writes_merged", static_cast<double>(writes_merged)); 703 res->SetDouble("sectors_written", static_cast<double>(sectors_written)); 704 res->SetDouble("write_time", static_cast<double>(write_time)); 705 res->SetDouble("io", static_cast<double>(io)); 706 res->SetDouble("io_time", static_cast<double>(io_time)); 707 res->SetDouble("weighted_io_time", static_cast<double>(weighted_io_time)); 708 709 return res.PassAs<Value>(); 710} 711 712bool IsValidDiskName(const std::string& candidate) { 713 if (candidate.length() < 3) 714 return false; 715 if (candidate.substr(0,2) == "sd" || candidate.substr(0,2) == "hd") { 716 // [sh]d[a-z]+ case 717 for (size_t i = 2; i < candidate.length(); i++) { 718 if (!islower(candidate[i])) 719 return false; 720 } 721 } else { 722 if (candidate.length() < 7) { 723 return false; 724 } 725 if (candidate.substr(0,6) == "mmcblk") { 726 // mmcblk[0-9]+ case 727 for (size_t i = 6; i < candidate.length(); i++) { 728 if (!isdigit(candidate[i])) 729 return false; 730 } 731 } else { 732 return false; 733 } 734 } 735 736 return true; 737} 738 739bool GetSystemDiskInfo(SystemDiskInfo* diskinfo) { 740 // Synchronously reading files in /proc is safe. 741 ThreadRestrictions::ScopedAllowIO allow_io; 742 743 FilePath diskinfo_file("/proc/diskstats"); 744 std::string diskinfo_data; 745 if (!ReadFileToString(diskinfo_file, &diskinfo_data)) { 746 DLOG(WARNING) << "Failed to open " << diskinfo_file.value(); 747 return false; 748 } 749 750 std::vector<std::string> diskinfo_lines; 751 size_t line_count = Tokenize(diskinfo_data, "\n", &diskinfo_lines); 752 if (line_count == 0) { 753 DLOG(WARNING) << "No lines found"; 754 return false; 755 } 756 757 diskinfo->reads = 0; 758 diskinfo->reads_merged = 0; 759 diskinfo->sectors_read = 0; 760 diskinfo->read_time = 0; 761 diskinfo->writes = 0; 762 diskinfo->writes_merged = 0; 763 diskinfo->sectors_written = 0; 764 diskinfo->write_time = 0; 765 diskinfo->io = 0; 766 diskinfo->io_time = 0; 767 diskinfo->weighted_io_time = 0; 768 769 uint64 reads = 0; 770 uint64 reads_merged = 0; 771 uint64 sectors_read = 0; 772 uint64 read_time = 0; 773 uint64 writes = 0; 774 uint64 writes_merged = 0; 775 uint64 sectors_written = 0; 776 uint64 write_time = 0; 777 uint64 io = 0; 778 uint64 io_time = 0; 779 uint64 weighted_io_time = 0; 780 781 for (size_t i = 0; i < line_count; i++) { 782 std::vector<std::string> disk_fields; 783 SplitStringAlongWhitespace(diskinfo_lines[i], &disk_fields); 784 785 // Fields may have overflowed and reset to zero. 786 if (IsValidDiskName(disk_fields[kDiskDriveName])) { 787 StringToUint64(disk_fields[kDiskReads], &reads); 788 StringToUint64(disk_fields[kDiskReadsMerged], &reads_merged); 789 StringToUint64(disk_fields[kDiskSectorsRead], §ors_read); 790 StringToUint64(disk_fields[kDiskReadTime], &read_time); 791 StringToUint64(disk_fields[kDiskWrites], &writes); 792 StringToUint64(disk_fields[kDiskWritesMerged], &writes_merged); 793 StringToUint64(disk_fields[kDiskSectorsWritten], §ors_written); 794 StringToUint64(disk_fields[kDiskWriteTime], &write_time); 795 StringToUint64(disk_fields[kDiskIO], &io); 796 StringToUint64(disk_fields[kDiskIOTime], &io_time); 797 StringToUint64(disk_fields[kDiskWeightedIOTime], &weighted_io_time); 798 799 diskinfo->reads += reads; 800 diskinfo->reads_merged += reads_merged; 801 diskinfo->sectors_read += sectors_read; 802 diskinfo->read_time += read_time; 803 diskinfo->writes += writes; 804 diskinfo->writes_merged += writes_merged; 805 diskinfo->sectors_written += sectors_written; 806 diskinfo->write_time += write_time; 807 diskinfo->io += io; 808 diskinfo->io_time += io_time; 809 diskinfo->weighted_io_time += weighted_io_time; 810 } 811 } 812 813 return true; 814} 815 816#if defined(OS_CHROMEOS) 817scoped_ptr<Value> SwapInfo::ToValue() const { 818 scoped_ptr<DictionaryValue> res(new DictionaryValue()); 819 820 // Write out uint64 variables as doubles. 821 // Note: this may discard some precision, but for JS there's no other option. 822 res->SetDouble("num_reads", static_cast<double>(num_reads)); 823 res->SetDouble("num_writes", static_cast<double>(num_writes)); 824 res->SetDouble("orig_data_size", static_cast<double>(orig_data_size)); 825 res->SetDouble("compr_data_size", static_cast<double>(compr_data_size)); 826 res->SetDouble("mem_used_total", static_cast<double>(mem_used_total)); 827 if (compr_data_size > 0) 828 res->SetDouble("compression_ratio", static_cast<double>(orig_data_size) / 829 static_cast<double>(compr_data_size)); 830 else 831 res->SetDouble("compression_ratio", 0); 832 833 return res.PassAs<Value>(); 834} 835 836void GetSwapInfo(SwapInfo* swap_info) { 837 // Synchronously reading files in /sys/block/zram0 is safe. 838 ThreadRestrictions::ScopedAllowIO allow_io; 839 840 base::FilePath zram_path("/sys/block/zram0"); 841 uint64 orig_data_size = ReadFileToUint64(zram_path.Append("orig_data_size")); 842 if (orig_data_size <= 4096) { 843 // A single page is compressed at startup, and has a high compression 844 // ratio. We ignore this as it doesn't indicate any real swapping. 845 swap_info->orig_data_size = 0; 846 swap_info->num_reads = 0; 847 swap_info->num_writes = 0; 848 swap_info->compr_data_size = 0; 849 swap_info->mem_used_total = 0; 850 return; 851 } 852 swap_info->orig_data_size = orig_data_size; 853 swap_info->num_reads = ReadFileToUint64(zram_path.Append("num_reads")); 854 swap_info->num_writes = ReadFileToUint64(zram_path.Append("num_writes")); 855 swap_info->compr_data_size = 856 ReadFileToUint64(zram_path.Append("compr_data_size")); 857 swap_info->mem_used_total = 858 ReadFileToUint64(zram_path.Append("mem_used_total")); 859} 860#endif // defined(OS_CHROMEOS) 861 862} // namespace base 863