Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp

   1 /*
   2  * Copyright (C) 2011, 2012 Apple Inc. All Rights Reserved.
   3  * Copyright (C) 2014 Raspberry Pi Foundation. All Rights Reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "config.h"
  28 #include "MemoryPressureHandler.h"
  29
  30 #if OS(LINUX)
  31
  32 #include "CurrentProcessMemoryStatus.h"
  33 #include "Logging.h"
  34
  35 #include <errno.h>
  36 #include <fcntl.h>
  37 #include <malloc.h>
  38 #include <sys/eventfd.h>
  39 #include <sys/stat.h>
  40 #include <sys/types.h>
  41 #include <unistd.h>
  42 #include <wtf/CurrentTime.h>
  43 #include <wtf/MainThread.h>
  44 #include <wtf/text/WTFString.h>
  45
  46 #if USE(GLIB)
  47 #include <glib-unix.h>
  48 #endif
  49
  50 namespace WebCore {
  51
  52 // Disable memory event reception for a minimum of s_minimumHoldOffTime
  53 // seconds after receiving an event. Don't let events fire any sooner than
  54 // s_holdOffMultiplier times the last cleanup processing time. Effectively
  55 // this is 1 / s_holdOffMultiplier percent of the time.
  56 // These value seems reasonable and testing verifies that it throttles frequent
  57 // low memory events, greatly reducing CPU usage.
  58 static const unsigned s_minimumHoldOffTime = 5;
  59 static const unsigned s_holdOffMultiplier = 20;
  60
  61 static const char* s_cgroupMemoryPressureLevel = "/sys/fs/cgroup/memory/memory.pressure_level";
  62 static const char* s_cgroupEventControl = "/sys/fs/cgroup/memory/cgroup.event_control";
  63
  64 #if USE(GLIB)
  65 typedef struct {
  66     GSource source;
  67     gpointer fdTag;
  68     GIOCondition condition;
  69 } EventFDSource;
  70
  71 static const unsigned eventFDSourceCondition = G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL;
  72
  73 static GSourceFuncs eventFDSourceFunctions = {
  74     nullptr, // prepare
  75     nullptr, // check
  76     // dispatch
  77     [](GSource* source, GSourceFunc callback, gpointer userData) -> gboolean
  78     {
  79         EventFDSource* eventFDSource = reinterpret_cast<EventFDSource*>(source);
  80         unsigned events = g_source_query_unix_fd(source, eventFDSource->fdTag) & eventFDSourceCondition;
  81         if (events & G_IO_HUP || events & G_IO_ERR || events & G_IO_NVAL)
  82             return G_SOURCE_REMOVE;
  83
  84         gboolean returnValue = G_SOURCE_CONTINUE;
  85         if (events & G_IO_IN)
  86             returnValue = callback(userData);
  87         g_source_set_ready_time(source, -1);
  88         return returnValue;
  89     },
  90     nullptr, // finalize
  91     nullptr, // closure_callback
  92     nullptr, // closure_marshall
  93 };
  94 #endif
  95
  96 MemoryPressureHandler::EventFDPoller::EventFDPoller(int fd, std::function<void ()>&& notifyHandler)
  97     : m_fd(fd)
  98     , m_notifyHandler(WTFMove(notifyHandler))
  99 {
 100 #if USE(GLIB)
 101     m_source = adoptGRef(g_source_new(&eventFDSourceFunctions, sizeof(EventFDSource)));
 102     g_source_set_name(m_source.get(), "WebCore: MemoryPressureHandler");
 103     if (!g_unix_set_fd_nonblocking(m_fd.value(), TRUE, nullptr)) {
 104         LOG(MemoryPressure, "Failed to set eventfd nonblocking");
 105         return;
 106     }
 107
 108     EventFDSource* eventFDSource = reinterpret_cast<EventFDSource*>(m_source.get());
 109     eventFDSource->fdTag = g_source_add_unix_fd(m_source.get(), m_fd.value(), static_cast<GIOCondition>(eventFDSourceCondition));
 110     g_source_set_callback(m_source.get(), [](gpointer userData) -> gboolean {
 111         static_cast<EventFDPoller*>(userData)->readAndNotify();
 112         return G_SOURCE_REMOVE;
 113     }, this, nullptr);
 114     g_source_attach(m_source.get(), nullptr);
 115 #else
 116     m_threadID = createThread("WebCore: MemoryPressureHandler", [this] { readAndNotify(); }
 117 #endif
 118 }
 119
 120 MemoryPressureHandler::EventFDPoller::~EventFDPoller()
 121 {
 122     m_fd = Nullopt;
 123 #if USE(GLIB)
 124     g_source_destroy(m_source.get());
 125 #else
 126     detachThread(m_threadID);
 127 #endif
 128 }
 129
 130 static inline bool isFatalReadError(int error)
 131 {
 132 #if USE(GLIB)
 133     // We don't really need to read the buffer contents, if the poller
 134     // notified us, but read would block or is no longer available, is
 135     // enough to trigger the memory pressure handler.
 136     return error != EAGAIN && error != EWOULDBLOCK;
 137 #else
 138     return true;
 139 #endif
 140 }
 141
 142 void MemoryPressureHandler::EventFDPoller::readAndNotify() const
 143 {
 144     if (!m_fd) {
 145         LOG(MemoryPressure, "Invalidate eventfd.");
 146         return;
 147     }
 148
 149     uint64_t buffer;
 150     if (read(m_fd.value(), &buffer, sizeof(buffer)) == -1) {
 151         if (isFatalReadError(errno)) {
 152             LOG(MemoryPressure, "Failed to read eventfd.");
 153             return;
 154         }
 155     }
 156
 157     m_notifyHandler();
 158 }
 159
 160 inline void MemoryPressureHandler::logErrorAndCloseFDs(const char* log)
 161 {
 162     if (log)
 163         LOG(MemoryPressure, "%s, error : %m", log);
 164
 165     if (m_eventFD) {
 166         close(m_eventFD.value());
 167         m_eventFD = Nullopt;
 168     }
 169     if (m_pressureLevelFD) {
 170         close(m_pressureLevelFD.value());
 171         m_pressureLevelFD = Nullopt;
 172     }
 173 }
 174
 175 bool MemoryPressureHandler::tryEnsureEventFD()
 176 {
 177     if (m_eventFD)
 178         return true;
 179
 180     // Try to use cgroups instead.
 181     int fd = eventfd(0, EFD_CLOEXEC);
 182     if (fd == -1) {
 183         LOG(MemoryPressure, "eventfd() failed: %m");
 184         return false;
 185     }
 186     m_eventFD = fd;
 187
 188     fd = open(s_cgroupMemoryPressureLevel, O_CLOEXEC | O_RDONLY);
 189     if (fd == -1) {
 190         logErrorAndCloseFDs("Failed to open memory.pressure_level");
 191         return false;
 192     }
 193     m_pressureLevelFD = fd;
 194
 195     fd = open(s_cgroupEventControl, O_CLOEXEC | O_WRONLY);
 196     if (fd == -1) {
 197         logErrorAndCloseFDs("Failed to open cgroup.event_control");
 198         return false;
 199     }
 200
 201     char line[128] = {0, };
 202     if (snprintf(line, sizeof(line), "%d %d low", m_eventFD.value(), m_pressureLevelFD.value()) < 0
 203         || write(fd, line, strlen(line) + 1) < 0) {
 204         logErrorAndCloseFDs("Failed to write cgroup.event_control");
 205         close(fd);
 206         return false;
 207     }
 208     close(fd);
 209
 210     return true;
 211 }
 212
 213 void MemoryPressureHandler::install()
 214 {
 215     if (m_installed || m_holdOffTimer.isActive())
 216         return;
 217
 218     if (!tryEnsureEventFD())
 219         return;
 220
 221     m_eventFDPoller = std::make_unique<EventFDPoller>(m_eventFD.value(), [this] {
 222         // FIXME: Current memcg does not provide any way for users to know how serious the memory pressure is.
 223         // So we assume all notifications from memcg are critical for now. If memcg had better inferfaces
 224         // to get a detailed memory pressure level in the future, we should update here accordingly.
 225         bool critical = true;
 226         if (ReliefLogger::loggingEnabled())
 227             LOG(MemoryPressure, "Got memory pressure notification (%s)", critical ? "critical" : "non-critical");
 228
 229         setUnderMemoryPressure(critical);
 230         if (isMainThread())
 231             respondToMemoryPressure(critical ? Critical::Yes : Critical::No);
 232         else
 233             RunLoop::main().dispatch([this, critical] { respondToMemoryPressure(critical ? Critical::Yes : Critical::No); });
 234     });
 235
 236     if (ReliefLogger::loggingEnabled() && isUnderMemoryPressure())
 237         LOG(MemoryPressure, "System is no longer under memory pressure.");
 238
 239     setUnderMemoryPressure(false);
 240     m_installed = true;
 241 }
 242
 243 void MemoryPressureHandler::uninstall()
 244 {
 245     if (!m_installed)
 246         return;
 247
 248     m_holdOffTimer.stop();
 249     m_eventFDPoller = nullptr;
 250
 251     if (m_pressureLevelFD) {
 252         close(m_pressureLevelFD.value());
 253         m_pressureLevelFD = Nullopt;
 254
 255         // Only close the eventFD used for cgroups.
 256         if (m_eventFD) {
 257             close(m_eventFD.value());
 258             m_eventFD = Nullopt;
 259         }
 260     }
 261
 262     m_installed = false;
 263 }
 264
 265 void MemoryPressureHandler::holdOffTimerFired()
 266 {
 267     install();
 268 }
 269
 270 void MemoryPressureHandler::holdOff(unsigned seconds)
 271 {
 272     m_holdOffTimer.startOneShot(seconds);
 273 }
 274
 275 static size_t processMemoryUsage()
 276 {
 277     ProcessMemoryStatus memoryStatus;
 278     currentProcessMemoryStatus(memoryStatus);
 279     return (memoryStatus.resident - memoryStatus.shared);
 280 }
 281
 282 void MemoryPressureHandler::respondToMemoryPressure(Critical critical, Synchronous synchronous)
 283 {
 284     uninstall();
 285
 286     double startTime = monotonicallyIncreasingTime();
 287     releaseMemory(critical, synchronous);
 288     unsigned holdOffTime = (monotonicallyIncreasingTime() - startTime) * s_holdOffMultiplier;
 289     holdOff(std::max(holdOffTime, s_minimumHoldOffTime));
 290 }
 291
 292 void MemoryPressureHandler::platformReleaseMemory(Critical)
 293 {
 294 #ifdef __GLIBC__
 295     ReliefLogger log("Run malloc_trim");
 296     malloc_trim(0);
 297 #endif
 298 }
 299
 300 size_t MemoryPressureHandler::ReliefLogger::platformMemoryUsage()
 301 {
 302     return processMemoryUsage();
 303 }
 304
 305 void MemoryPressureHandler::setMemoryPressureMonitorHandle(int fd)
 306 {
 307     ASSERT(!m_eventFD);
 308     m_eventFD = fd;
 309 }
 310
 311 } // namespace WebCore
 312
 313 #endif // OS(LINUX)