Linux: use /proc/pid/statm to get memory stats when /proc/pid/smaps is unavai...

base/process_util_linux.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/process_util.h"
 
 #include <ctype.h>
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <time.h>
 #include <unistd.h>
 
-#include <string>
-
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 
 namespace {
 
 enum ParsingState {
   KEY_NAME,
   KEY_VALUE
@@ skipping 217 matching lines @@
   }
   return 0;
 }
 
 size_t ProcessMetrics::GetPrivateBytes() const {
   WorkingSetKBytes ws_usage;
   GetWorkingSetKBytes(&ws_usage);
   return ws_usage.priv << 10;
 }
 
-// Private and Shared working set sizes are obtained from /proc/<pid>/smaps,
-// as in http://www.pixelbeat.org/scripts/ps_mem.py
+// Private and Shared working set sizes are obtained from /proc/<pid>/smaps.
+// When that's not available, use the values from /proc<pid>/statm as a
+// close approximation.
+// See http://www.pixelbeat.org/scripts/ps_mem.py
 bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const {
   FilePath stat_file =
     FilePath("/proc").Append(IntToString(process_)).Append("smaps");
   std::string smaps;
   int private_kb = 0;
   int pss_kb = 0;
   bool have_pss = false;
-  if (!file_util::ReadFileToString(stat_file, &smaps) || smaps.length() == 0)
-    return false;
+  if (file_util::ReadFileToString(stat_file, &smaps) && smaps.length() > 0) {
+    StringTokenizer tokenizer(smaps, ":\n");
+    ParsingState state = KEY_NAME;
+    std::string last_key_name;
+    while (tokenizer.GetNext()) {
+      switch (state) {
+        case KEY_NAME:
+          last_key_name = tokenizer.token();
+          state = KEY_VALUE;
+          break;
+        case KEY_VALUE:
+          if (last_key_name.empty()) {
+            NOTREACHED();
+            return false;
+          }
+          if (StartsWithASCII(last_key_name, "Private_", 1)) {
+            private_kb += StringToInt(tokenizer.token());
+          } else if (StartsWithASCII(last_key_name, "Pss", 1)) {
+            have_pss = true;
+            pss_kb += StringToInt(tokenizer.token());
+          }
+          state = KEY_NAME;
+          break;
+      }
+    }
+  } else {
+    // Try statm if smaps is empty because of the SUID sandbox.
+    // First we need to get the page size though.
+    int page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024;
+    if (page_size_kb <= 0)
+      return false;
 
-  StringTokenizer tokenizer(smaps, ":\n");
-  ParsingState state = KEY_NAME;
-  std::string last_key_name;
-  while (tokenizer.GetNext()) {
-    switch (state) {
-      case KEY_NAME:
-        last_key_name = tokenizer.token();
-        state = KEY_VALUE;
-        break;
-      case KEY_VALUE:
-        if (last_key_name.empty()) {
-          NOTREACHED();
-          return false;
-        }
-        if (StartsWithASCII(last_key_name, "Private_", 1)) {
-          private_kb += StringToInt(tokenizer.token());
-        } else if (StartsWithASCII(last_key_name, "Pss", 1)) {
-          have_pss = true;
-          pss_kb += StringToInt(tokenizer.token());
-        }
-        state = KEY_NAME;
-        break;
-    }
+    stat_file =
+        FilePath("/proc").Append(IntToString(process_)).Append("statm");
+    std::string statm;
+    if (!file_util::ReadFileToString(stat_file, &statm) || statm.length() == 0)
+      return false;
+
+    std::vector<std::string> statm_vec;
+    SplitString(statm, ' ', &statm_vec);
+    if (statm_vec.size() != 7)
+      return false;  // Not the format we expect.
+    private_kb = StringToInt(statm_vec[1]) - StringToInt(statm_vec[2]);
+    private_kb *= page_size_kb;
   }
   ws_usage->priv = private_kb;
   // Sharable is not calculated, as it does not provide interesting data.
   ws_usage->shareable = 0;
 
   ws_usage->shared = 0;
   if (have_pss)
     ws_usage->shared = pss_kb;
   return true;
 }
@@ skipping 106 matching lines @@
   int64 time = TimeValToMicroseconds(now);
 
   if (last_time_ == 0) {
     // First call, just set the last values.
     last_time_ = time;
     last_cpu_ = GetProcessCPU(process_);
     return 0;
   }
 
   int64 time_delta = time - last_time_;
-  DCHECK(time_delta != 0);
+  DCHECK_NE(time_delta, 0);
   if (time_delta == 0)
     return 0;
 
   int cpu = GetProcessCPU(process_);
 
   // We have the number of jiffies in the time period.  Convert to percentage.
   // Note this means we will go *over* 100 in the case where multiple threads
   // are together adding to more than one CPU's worth.
   int percentage = 100 * (cpu - last_cpu_) /
       (kHertz * TimeDelta::FromMicroseconds(time_delta).InSecondsF());
 
   last_time_ = time;
   last_cpu_ = cpu;
 
   return percentage;
 }
 
 }  // namespace base