[base/debug] Add function to read smaps_rollup

This CL adds a utility function for reading /proc/self/smaps_rollup,
which will be used to measure the impact of compacting process memory on
Android.

Bug: 375387998
Change-Id: Id0f4852e86759411d37678f84e64d8f6b8a514e1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5960816
Commit-Queue: Thiabaud Engelbrecht <thiabaud@google.com>
Reviewed-by: Francois Pierre Doray <fdoray@chromium.org>
Reviewed-by: Benoit Lize <lizeb@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1375245}


CrOS-Libchrome-Original-Commit: 309fb1eaad193ff82fbc3f00e158ea65e7332cdc

Author: Thiabaud Engelbrecht

base/debug/proc_maps_linux.cc

@@ -14,7 +14,9 @@
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
+#include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/memory/page_size.h"
 #include "base/strings/string_split.h"
 #include "build/build_config.h"
 
@@ -170,5 +172,72 @@ bool ParseProcMaps(const std::string& input,
   return true;
 }
 
+std::optional<SmapsRollup> ParseSmapsRollup(const std::string& buffer) {
+  std::vector<std::string> lines =
+      SplitString(buffer, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+
+  std::unordered_map<std::string, size_t> tmp;
+  for (const auto& line : lines) {
+    // This should be more than enough space for any output we get (but we also
+    // verify the size below).
+    std::string key;
+    key.resize(100);
+    size_t val;
+    if (sscanf(line.c_str(), "%99s %" PRIuS " kB", key.data(), &val) == 2) {
+      // sscanf writes a nul-byte at the end of the result, so |strlen| is safe
+      // here. |resize| does not count the length of the nul-byte, and we want
+      // to trim off the trailing colon at the end, so we use |strlen - 1| here.
+      key.resize(strlen(key.c_str()) - 1);
+      tmp[key] = val * 1024;
+    }
+  }
+
+  SmapsRollup smaps_rollup;
+
+  smaps_rollup.rss = tmp["Rss"];
+  smaps_rollup.pss = tmp["Pss"];
+  smaps_rollup.pss_anon = tmp["Pss_Anon"];
+  smaps_rollup.pss_file = tmp["Pss_File"];
+  smaps_rollup.pss_shmem = tmp["Pss_Shmem"];
+  smaps_rollup.private_dirty = tmp["Private_Dirty"];
+  smaps_rollup.swap = tmp["Swap"];
+  smaps_rollup.swap_pss = tmp["SwapPss"];
+
+  return smaps_rollup;
+}
+
+std::optional<SmapsRollup> ReadAndParseSmapsRollup() {
+  const size_t read_size = base::GetPageSize();
+
+  base::ScopedFD fd(HANDLE_EINTR(open("/proc/self/smaps_rollup", O_RDONLY)));
+  if (!fd.is_valid()) {
+    DPLOG(ERROR) << "Couldn't open /proc/self/smaps_rollup";
+    return std::nullopt;
+  }
+
+  std::string buffer;
+  buffer.resize(read_size);
+
+  ssize_t bytes_read = HANDLE_EINTR(
+      read(fd.get(), static_cast<void*>(buffer.data()), read_size));
+  if (bytes_read < 0) {
+    DPLOG(ERROR) << "Couldn't read /proc/self/smaps_rollup";
+    return std::nullopt;
+  }
+
+  // We expect to read a few hundred bytes, which should be significantly less
+  // the page size.
+  DCHECK(static_cast<size_t>(bytes_read) < read_size);
+
+  buffer.resize(static_cast<size_t>(bytes_read));
+
+  return ParseSmapsRollup(buffer);
+}
+
+std::optional<SmapsRollup> ParseSmapsRollupForTesting(
+    const std::string& smaps_rollup) {
+  return ParseSmapsRollup(smaps_rollup);
+}
+
 }  // namespace debug
 }  // namespace base

base/debug/proc_maps_linux.h

@@ -7,13 +7,13 @@
 
 #include <stdint.h>
 
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 
-namespace base {
-namespace debug {
+namespace base::debug {
 
 // Describes a region of mapped memory and the path of the file mapped.
 struct BASE_EXPORT MappedMemoryRegion {
@@ -96,7 +96,24 @@ BASE_EXPORT bool ReadProcMaps(std::string* proc_maps);
 BASE_EXPORT bool ParseProcMaps(const std::string& input,
                                std::vector<MappedMemoryRegion>* regions);
 
-}  // namespace debug
-}  // namespace base
+struct SmapsRollup {
+  size_t rss = 0;
+  size_t pss = 0;
+  size_t pss_anon = 0;
+  size_t pss_file = 0;
+  size_t pss_shmem = 0;
+  size_t private_dirty = 0;
+  size_t swap = 0;
+  size_t swap_pss = 0;
+};
+
+// Attempts to read /proc/self/smaps_rollup. Returns nullopt on error.
+BASE_EXPORT std::optional<SmapsRollup> ReadAndParseSmapsRollup();
+
+// |smaps_rollup| should be the result of reading /proc/*/smaps_rollup.
+BASE_EXPORT std::optional<SmapsRollup> ParseSmapsRollupForTesting(
+    const std::string& smaps_rollup);
+
+}  // namespace base::debug
 
 #endif  // BASE_DEBUG_PROC_MAPS_LINUX_H_

base/debug/proc_maps_linux_unittest.cc

@@ -11,16 +11,44 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <sys/utsname.h>
 
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
+#include "base/system/sys_info.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace base {
-namespace debug {
+namespace base::debug {
+
+namespace {
+
+// SmapsRollup was added in Linux 4.14.
+bool IsSmapsRollupSupported() {
+  struct utsname info;
+  if (uname(&info) < 0) {
+    NOTREACHED();
+  }
+
+  int major, minor, patch;
+  if (sscanf(info.release, "%d.%d.%d", &major, &minor, &patch) < 3) {
+    NOTREACHED();
+  }
+
+  if (major > 4) {
+    return true;
+  }
+
+  if (major < 4 || minor < 14) {
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace
 
 TEST(ProcMapsTest, Empty) {
   std::vector<MappedMemoryRegion> regions;
@@ -330,5 +358,65 @@ TEST(ProcMapsTest, ParseProcMapsWeirdCorrectInput) {
   EXPECT_EQ("[vsys call]", regions[4].path);
 }
 
-}  // namespace debug
-}  // namespace base
+TEST(SmapsRollupTest, ReadAndParse) {
+  if (!IsSmapsRollupSupported()) {
+    GTEST_SKIP() << "smaps_rollup not supported";
+  }
+
+  const auto result = ReadAndParseSmapsRollup();
+
+  EXPECT_TRUE(result.has_value());
+
+  SmapsRollup smaps_rollup = result.value();
+
+  EXPECT_GT(smaps_rollup.rss, 0u);
+  EXPECT_GT(smaps_rollup.pss, 0u);
+  EXPECT_GT(smaps_rollup.pss_anon, 0u);
+  EXPECT_GT(smaps_rollup.private_dirty, 0u);
+}
+
+TEST(SmapsRollupTest, Valid) {
+  const auto result = ParseSmapsRollupForTesting(
+      // This input is based on a real one captured locally, but with some
+      // values changed in order to make them unique (to test that the correct
+      // values are being parsed).
+      R"(55f4d118e000-7ffff6e62000 ---p 00000000 00:00 0                          [rollup]
+Rss:                1908 kB
+Pss:                 573 kB
+Pss_Dirty:           144 kB
+Pss_Anon:            100 kB
+Pss_File:            469 kB
+Pss_Shmem:            12 kB
+Shared_Clean:       1356 kB
+Shared_Dirty:          0 kB
+Private_Clean:       448 kB
+Private_Dirty:       104 kB
+Referenced:         1900 kB
+Anonymous:           105 kB
+KSM:                   0 kB
+LazyFree:              0 kB
+AnonHugePages:         0 kB
+ShmemPmdMapped:        0 kB
+FilePmdMapped:         0 kB
+Shared_Hugetlb:        0 kB
+Private_Hugetlb:       0 kB
+Swap:                 10 kB
+SwapPss:              20 kB
+Locked:                0 kB
+)");
+
+  EXPECT_TRUE(result.has_value());
+
+  SmapsRollup smaps_rollup = result.value();
+
+  EXPECT_EQ(smaps_rollup.rss, 1024 * 1908u);
+  EXPECT_EQ(smaps_rollup.pss, 1024 * 573u);
+  EXPECT_EQ(smaps_rollup.private_dirty, 1024 * 104u);
+  EXPECT_EQ(smaps_rollup.pss_anon, 1024 * 100u);
+  EXPECT_EQ(smaps_rollup.pss_file, 1024 * 469u);
+  EXPECT_EQ(smaps_rollup.pss_shmem, 1024 * 12u);
+  EXPECT_EQ(smaps_rollup.swap, 1024 * 10u);
+  EXPECT_EQ(smaps_rollup.swap_pss, 1024 * 20u);
+}
+
+}  // namespace base::debug