Add D-Bus interface for handling memory pressure

This interface exports the function provided by the chromeos memory
pressure module in //chromeos/memory/pressure/. This interface will be
used by chrome, CrOS VM and ARCVM to query system memory pressure
status. The clients of this interface shall try to release memory when
the memory pressure is high.

BUG=b:149833548
Test: dbus-send --system --type=method_call --print-reply \
    --dest=org.chromium.MemoryPressure /org/chromium/MemoryPressure \
    org.chromium.MemoryPressure.GetAvailableMemoryKB

Change-Id: I795b688433ef8c5ab58a7d2099f369655f7b41c8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2409423Reviewed-by: Jorge Lucangeli Obes <jorgelo@chromium.org>
Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Reviewed-by: Brian Geffon <bgeffon@chromium.org>
Commit-Queue: Kuo-Hsin Yang <vovoy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#807548}

chrome/browser/chromeos/BUILD.gn

@@ -180,6 +180,7 @@ source_set("chromeos") {
     "//chromeos/login/auth",
     "//chromeos/login/login_state",
     "//chromeos/login/session",
+    "//chromeos/memory",
     "//chromeos/network",
     "//chromeos/resources:diagnostics_app_resources_grit",
     "//chromeos/resources:media_app_resources_grit",
@@ -1059,6 +1060,8 @@ source_set("chromeos") {
     "dbus/lock_to_single_user_service_provider.h",
     "dbus/machine_learning_decision_service_provider.cc",
     "dbus/machine_learning_decision_service_provider.h",
+    "dbus/memory_pressure_service_provider.cc",
+    "dbus/memory_pressure_service_provider.h",
     "dbus/metrics_event_service_provider.cc",
     "dbus/metrics_event_service_provider.h",
     "dbus/plugin_vm_service_provider.cc",
@@ -2870,6 +2873,7 @@ action("dbus_service_files") {
     "dbus/org.chromium.LibvdaService.conf",
     "dbus/org.chromium.LockToSingleUser.conf",
     "dbus/org.chromium.MachineLearningDecisionService.conf",
+    "dbus/org.chromium.MemoryPressure.conf",
     "dbus/org.chromium.MetricsEventService.conf",
     "dbus/org.chromium.NetworkProxyService.conf",
     "dbus/org.chromium.PluginVmService.conf",

chrome/browser/chromeos/chrome_browser_main_chromeos.cc

@@ -56,6 +56,7 @@
 #include "chrome/browser/chromeos/dbus/libvda_service_provider.h"
 #include "chrome/browser/chromeos/dbus/lock_to_single_user_service_provider.h"
 #include "chrome/browser/chromeos/dbus/machine_learning_decision_service_provider.h"
+#include "chrome/browser/chromeos/dbus/memory_pressure_service_provider.h"
 #include "chrome/browser/chromeos/dbus/metrics_event_service_provider.h"
 #include "chrome/browser/chromeos/dbus/plugin_vm_service_provider.h"
 #include "chrome/browser/chromeos/dbus/printers_service_provider.h"
@@ -355,6 +356,12 @@ class DBusServices {
         CrosDBusService::CreateServiceProviderList(
             std::make_unique<LockToSingleUserServiceProvider>()));
 
+    memory_pressure_service_ = CrosDBusService::Create(
+        system_bus, memory_pressure::kMemoryPressureServiceName,
+        dbus::ObjectPath(memory_pressure::kMemoryPressureServicePath),
+        CrosDBusService::CreateServiceProviderList(
+            std::make_unique<MemoryPressureServiceProvider>()));
+
     if (arc::IsArcVmEnabled()) {
       libvda_service_ = CrosDBusService::Create(
           system_bus, libvda::kLibvdaServiceName,
@@ -415,6 +422,7 @@ class DBusServices {
     drive_file_stream_service_.reset();
     cryptohome_key_delegate_service_.reset();
     lock_to_single_user_service_.reset();
+    memory_pressure_service_.reset();
     ProcessDataCollector::Shutdown();
     PowerDataCollector::Shutdown();
     PowerPolicyController::Shutdown();
@@ -444,6 +452,7 @@ class DBusServices {
   std::unique_ptr<CrosDBusService> machine_learning_decision_service_;
   std::unique_ptr<CrosDBusService> smb_fs_service_;
   std::unique_ptr<CrosDBusService> lock_to_single_user_service_;
+  std::unique_ptr<CrosDBusService> memory_pressure_service_;
 
   DISALLOW_COPY_AND_ASSIGN(DBusServices);
 };

chrome/browser/chromeos/dbus/memory_pressure_service_provider.cc

+// Copyright 2020 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 "chrome/browser/chromeos/dbus/memory_pressure_service_provider.h"
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "chromeos/memory/pressure/pressure.h"
+#include "dbus/bus.h"
+#include "dbus/message.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
+
+namespace chromeos {
+
+MemoryPressureServiceProvider::MemoryPressureServiceProvider() = default;
+
+MemoryPressureServiceProvider::~MemoryPressureServiceProvider() = default;
+
+void MemoryPressureServiceProvider::Start(
+    scoped_refptr<dbus::ExportedObject> exported_object) {
+  exported_object->ExportMethod(
+      memory_pressure::kMemoryPressureInterface,
+      memory_pressure::kGetAvailableMemoryKBMethod,
+      base::BindRepeating(&MemoryPressureServiceProvider::GetAvailableMemoryKB,
+                          weak_ptr_factory_.GetWeakPtr()),
+      base::BindRepeating(&MemoryPressureServiceProvider::OnExported,
+                          weak_ptr_factory_.GetWeakPtr()));
+  exported_object->ExportMethod(
+      memory_pressure::kMemoryPressureInterface,
+      memory_pressure::kGetMemoryMarginKBMethod,
+      base::BindRepeating(&MemoryPressureServiceProvider::GetMemoryMarginsKB,
+                          weak_ptr_factory_.GetWeakPtr()),
+      base::BindRepeating(&MemoryPressureServiceProvider::OnExported,
+                          weak_ptr_factory_.GetWeakPtr()));
+}
+
+void MemoryPressureServiceProvider::OnExported(
+    const std::string& interface_name,
+    const std::string& method_name,
+    bool success) {
+  LOG_IF(ERROR, !success) << "Failed to export " << interface_name << "."
+                          << method_name;
+}
+
+void MemoryPressureServiceProvider::GetAvailableMemoryKB(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender) {
+  std::unique_ptr<dbus::Response> response =
+      dbus::Response::FromMethodCall(method_call);
+  dbus::MessageWriter writer(response.get());
+  writer.AppendUint64(chromeos::memory::pressure::GetAvailableMemoryKB());
+  std::move(response_sender).Run(std::move(response));
+}
+
+void MemoryPressureServiceProvider::GetMemoryMarginsKB(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender) {
+  std::unique_ptr<dbus::Response> response =
+      dbus::Response::FromMethodCall(method_call);
+  dbus::MessageWriter writer(response.get());
+  std::pair<uint64_t, uint64_t> margins =
+      chromeos::memory::pressure::GetMemoryMarginsKB();
+  writer.AppendUint64(margins.first);
+  writer.AppendUint64(margins.second);
+  std::move(response_sender).Run(std::move(response));
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/dbus/memory_pressure_service_provider.h

+// Copyright 2020 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_DBUS_MEMORY_PRESSURE_SERVICE_PROVIDER_H_
+#define CHROME_BROWSER_CHROMEOS_DBUS_MEMORY_PRESSURE_SERVICE_PROVIDER_H_
+
+#include <string>
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "chromeos/dbus/services/cros_dbus_service.h"
+#include "dbus/exported_object.h"
+
+namespace dbus {
+class MethodCall;
+}
+
+namespace chromeos {
+
+// This class exports D-Bus methods for handling memory pressure.
+//
+// This service can be manually tested using dbus-send:
+// % dbus-send --system --type=method_call --print-reply
+//     --dest=org.chromium.MemoryPressure /org/chromium/MemoryPressure
+//     org.chromium.MemoryPressure.GetAvailableMemoryKB
+class MemoryPressureServiceProvider
+    : public CrosDBusService::ServiceProviderInterface {
+ public:
+  MemoryPressureServiceProvider();
+  MemoryPressureServiceProvider& operator=(
+      const MemoryPressureServiceProvider&) = delete;
+  MemoryPressureServiceProvider(const MemoryPressureServiceProvider&) = delete;
+  ~MemoryPressureServiceProvider() override;
+
+  // CrosDBusService::ServiceProviderInterface overrides:
+  void Start(scoped_refptr<dbus::ExportedObject> exported_object) override;
+
+ private:
+  void OnExported(const std::string& interface_name,
+                  const std::string& method_name,
+                  bool success);
+
+  void GetAvailableMemoryKB(
+      dbus::MethodCall* method_call,
+      dbus::ExportedObject::ResponseSender response_sender);
+
+  void GetMemoryMarginsKB(dbus::MethodCall* method_call,
+                          dbus::ExportedObject::ResponseSender response_sender);
+
+  // TODO(b/149833548): Implement signals CriticalMemoryPressure and
+  // ModerateMemoryPressure.
+
+  base::WeakPtrFactory<MemoryPressureServiceProvider> weak_ptr_factory_{this};
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_DBUS_MEMORY_PRESSURE_SERVICE_PROVIDER_H_

chrome/browser/chromeos/dbus/org.chromium.MemoryPressure.conf

+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+  "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<!--
+  Copyright 2020 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.
+-->
+<busconfig>
+  <policy user="chronos">
+    <allow own="org.chromium.MemoryPressure"/>
+    <allow receive_sender="org.chromium.MemoryPressure"
+           receive_interface="org.chromium.MemoryPressure"/>
+  </policy>
+
+  <!--
+    Handling memory pressure.
+  -->
+  <policy user="chronos">
+    <allow send_destination="org.chromium.MemoryPressure"
+           send_interface="org.chromium.MemoryPressure"/>
+  </policy>
+  <policy user="root">
+    <allow send_destination="org.chromium.MemoryPressure"
+           send_interface="org.chromium.MemoryPressure"/>
+  </policy>
+</busconfig>

chromeos/memory/pressure/pressure.cc

@@ -173,6 +173,11 @@ uint64_t GetAvailableMemoryKB() {
                                              ram_swap_weight);
 }
 
+std::pair<uint64_t, uint64_t> GetMemoryMarginsKB() {
+  // TODO(b/149833548): Implement this function.
+  return {0, 0};
+}
+
 void UpdateMemoryParameters() {
   reserved_free = GetReservedMemoryKB();
   min_filelist = ReadFileToUint64(base::FilePath(kMinFilelist));

chromeos/memory/pressure/pressure.h

@@ -7,6 +7,7 @@
 
 #include <cstdint>
 #include <string>
+#include <utility>
 
 #include "base/process/process_metrics.h"
 #include "chromeos/chromeos_export.h"
@@ -26,7 +27,12 @@ CalculateAvailableMemoryUserSpaceKB(const base::SystemMemoryInfoKB& info,
                                     uint64_t ram_swap_weight);
 
 // GetAvailableMemoryKB returns the available memory in KiB.
-uint64_t GetAvailableMemoryKB();
+CHROMEOS_EXPORT uint64_t GetAvailableMemoryKB();
+
+// GetMemoryMarginsKB returns a pair of uint64_t. The first value is the
+// critical memory pressure level, the second value is the moderate memory
+// pressure level.
+CHROMEOS_EXPORT std::pair<uint64_t, uint64_t> GetMemoryMarginsKB();
 
 // The memory parameters are saved for optimization.  If these memory
 // parameters are changed, call this function to update the saved values.