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