The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* vim: set ts=2 et sw=2 tw=80: */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #include "GonkMemoryPressureMonitoring.h"

 #include "mozilla/ArrayUtils.h"

 #include "mozilla/FileUtils.h"

 #include "mozilla/Monitor.h"

 #include "mozilla/Preferences.h"

 #include "mozilla/ProcessPriorityManager.h"

 #include "mozilla/Services.h"

 #include "nsIObserver.h"

 #include "nsIObserverService.h"

 #include "nsMemoryPressure.h"

 #include "nsThreadUtils.h"

 #include <errno.h>

 #include <fcntl.h>

 #include <poll.h>

 #include <android/log.h>

 #define LOG(args...)  \

   __android_log_print(ANDROID_LOG_INFO, "GonkMemoryPressure" , ## args)

 #ifdef MOZ_NUWA_PROCESS

 #include "ipc/Nuwa.h"

 #endif

 using namespace mozilla;

 namespace {

 /**

  * MemoryPressureWatcher watches sysfs from its own thread to notice when the

  * system is under memory pressure.  When we observe memory pressure, we use

  * MemoryPressureRunnable to notify observers that they should release memory.

  *

  * When the system is under memory pressure, we don't want to constantly fire

  * memory-pressure events.  So instead, we try to detect when sysfs indicates

  * that we're no longer under memory pressure, and only then start firing events

  * again.

  *

  * (This is a bit problematic because we can't poll() to detect when we're no

  * longer under memory pressure; instead we have to periodically read the sysfs

  * node.  If we remain under memory pressure for a long time, this means we'll

  * continue waking up to read from the node for a long time, potentially wasting

  * battery life.  Hopefully we don't hit this case in practice!  We write to

  * logcat each time we go around this loop so it's at least noticable.)

  *

  * Shutting down safely is a bit of a chore.  XPCOM won't shut down until all

  * threads exit, so we need to exit the Run() method below on shutdown.  But our

  * thread might be blocked in one of two situations: We might be poll()'ing the

  * sysfs node waiting for memory pressure to occur, or we might be asleep

  * waiting to read() the sysfs node to see if we're no longer under memory

  * pressure.

  *

  * To let us wake up from the poll(), we poll() not just the sysfs node but also

  * a pipe, which we write to on shutdown.  To let us wake up from sleeping

  * between read()s, we sleep by Wait()'ing on a monitor, which we notify on

  * shutdown.

  */

 class MemoryPressureWatcher

   : public nsIRunnable

   , public nsIObserver

 {

 public:

   MemoryPressureWatcher()

     : mMonitor("MemoryPressureWatcher")

     , mShuttingDown(false)

   {

   }

   NS_DECL_THREADSAFE_ISUPPORTS

   nsresult Init()

   {

     nsCOMPtr<nsIObserverService> os = services::GetObserverService();

     NS_ENSURE_STATE(os);

     // The observer service holds us alive.

     os->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, /* holdsWeak */ false);

     // While we're under memory pressure, we periodically read()

     // notify_trigger_active to try and see when we're no longer under memory

     // pressure.  mPollMS indicates how many milliseconds we wait between those

     // read()s.

     mPollMS = Preferences::GetUint("gonk.systemMemoryPressureRecoveryPollMS",

                                    /* default */ 5000);

     int pipes[2];

     NS_ENSURE_STATE(!pipe(pipes));

     mShutdownPipeRead = pipes[0];

     mShutdownPipeWrite = pipes[1];

     return NS_OK;

   }

   NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic,

                      const char16_t* aData)

   {

     MOZ_ASSERT(strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0);

     LOG("Observed XPCOM shutdown.");

     MonitorAutoLock lock(mMonitor);

     mShuttingDown = true;

     mMonitor.Notify();

     int rv;

     do {

       // Write something to the pipe; doesn't matter what.

       uint32_t dummy = 0;

       rv = write(mShutdownPipeWrite, &dummy, sizeof(dummy));

     } while(rv == -1 && errno == EINTR);

     return NS_OK;

   }

   NS_IMETHOD Run()

   {

     MOZ_ASSERT(!NS_IsMainThread());

 #ifdef MOZ_NUWA_PROCESS

     if (IsNuwaProcess()) {

       NS_ASSERTION(NuwaMarkCurrentThread != nullptr,

                    "NuwaMarkCurrentThread is undefined!");

       NuwaMarkCurrentThread(nullptr, nullptr);

     }

 #endif

     int lowMemFd = open("/sys/kernel/mm/lowmemkiller/notify_trigger_active",

                         O_RDONLY | O_CLOEXEC);

     NS_ENSURE_STATE(lowMemFd != -1);

     ScopedClose autoClose(lowMemFd);

     nsresult rv = CheckForMemoryPressure(lowMemFd, nullptr);

     NS_ENSURE_SUCCESS(rv, rv);

     while (true) {

       // Wait for a notification on lowMemFd or for data to be written to

       // mShutdownPipeWrite.  (poll(lowMemFd, POLLPRI) blocks until we're under

       // memory pressure.)

       struct pollfd pollfds[2];

       pollfds[0].fd = lowMemFd;

       pollfds[0].events = POLLPRI;

       pollfds[1].fd = mShutdownPipeRead;

       pollfds[1].events = POLLIN;

       int pollRv;

       do {

         pollRv = poll(pollfds, ArrayLength(pollfds), /* timeout */ -1);

       } while (pollRv == -1 && errno == EINTR);

       if (pollfds[1].revents) {

         // Something was written to our shutdown pipe; we're outta here.

         LOG("shutting down (1)");

         return NS_OK;

       }

       // If pollfds[1] isn't happening, pollfds[0] ought to be!

       if (!(pollfds[0].revents & POLLPRI)) {

         LOG("Unexpected revents value after poll(): %d. "

             "Shutting down GonkMemoryPressureMonitoring.", pollfds[0].revents);

         return NS_ERROR_FAILURE;

       }

       // POLLPRI on lowMemFd indicates that we're in a low-memory situation.  We

       // could read lowMemFd to double-check, but we've observed that the read

       // sometimes completes after the memory-pressure event is over, so let's

       // just believe the result of poll().

       // We use low-memory-no-forward because each process has its own watcher

       // and thus there is no need for the main process to forward this event.

       rv = DispatchMemoryPressure(MemPressure_New);

       NS_ENSURE_SUCCESS(rv, rv);

       // Manually check lowMemFd until we observe that memory pressure is over.

       // We won't fire any more low-memory events until we observe that

       // we're no longer under pressure. Instead, we fire low-memory-ongoing

       // events, which cause processes to keep flushing caches but will not

       // trigger expensive GCs and other attempts to save memory that are

       // likely futile at this point.

       bool memoryPressure;

       do {

         {

           MonitorAutoLock lock(mMonitor);

           // We need to check mShuttingDown before we wait here, in order to

           // catch a shutdown signal sent after we poll()'ed mShutdownPipeRead

           // above but before we started waiting on the monitor.  But we don't

           // need to check after we wait, because we'll either do another

           // iteration of this inner loop, in which case we'll check

           // mShuttingDown, or we'll exit this loop and do another iteration

           // of the outer loop, in which case we'll check the shutdown pipe.

           if (mShuttingDown) {

             LOG("shutting down (2)");

             return NS_OK;

           }

           mMonitor.Wait(PR_MillisecondsToInterval(mPollMS));

         }

         LOG("Checking to see if memory pressure is over.");

         rv = CheckForMemoryPressure(lowMemFd, &memoryPressure);

         NS_ENSURE_SUCCESS(rv, rv);

         if (memoryPressure) {

           rv = DispatchMemoryPressure(MemPressure_Ongoing);

           NS_ENSURE_SUCCESS(rv, rv);

           continue;

         }

       } while (false);

       LOG("Memory pressure is over.");

     }

     return NS_OK;

   }

 private:

   /**

    * Read from aLowMemFd, which we assume corresponds to the

    * notify_trigger_active sysfs node, and determine whether we're currently

    * under memory pressure.

    *

    * We don't expect this method to block.

    */

   nsresult CheckForMemoryPressure(int aLowMemFd, bool* aOut)

   {

     if (aOut) {

       *aOut = false;

     }

     lseek(aLowMemFd, 0, SEEK_SET);

     char buf[2];

     int nread;

     do {

       nread = read(aLowMemFd, buf, sizeof(buf));

     } while(nread == -1 && errno == EINTR);

     NS_ENSURE_STATE(nread == 2);

     // The notify_trigger_active sysfs node should contain either "0\n" or

     // "1\n".  The latter indicates memory pressure.

     if (aOut) {

       *aOut = buf[0] == '1' && buf[1] == '\n';

     }

     return NS_OK;

   }

   /**

    * Dispatch the specified memory pressure event unless a high-priority

    * process is present. If a high-priority process is present then it's likely

    * responding to an urgent event (an incoming call or message for example) so

    * avoid wasting CPU time responding to low-memory events.

    */

   nsresult DispatchMemoryPressure(MemoryPressureState state)

   {

     if (ProcessPriorityManager::AnyProcessHasHighPriority()) {

       return NS_OK;

     }

     return NS_DispatchMemoryPressure(state);

   }

   Monitor mMonitor;

   uint32_t mPollMS;

   bool mShuttingDown;

   ScopedClose mShutdownPipeRead;

   ScopedClose mShutdownPipeWrite;

 };

 NS_IMPL_ISUPPORTS(MemoryPressureWatcher, nsIRunnable, nsIObserver);

 } // anonymous namespace

 namespace mozilla {

 void

 InitGonkMemoryPressureMonitoring()

 {

   // memoryPressureWatcher is held alive by the observer service.

   nsRefPtr<MemoryPressureWatcher> memoryPressureWatcher =

     new MemoryPressureWatcher();

   NS_ENSURE_SUCCESS_VOID(memoryPressureWatcher->Init());

   nsCOMPtr<nsIThread> thread;

   NS_NewThread(getter_AddRefs(thread), memoryPressureWatcher);

 }

 } // namespace mozilla