The Tor Browser: hal/gonk/GonkDiskSpaceWatcher.cpp@129ffea94266 (annotated)

hal/gonk/GonkDiskSpaceWatcher.cpp@129ffea94266 (annotated)

hal/gonk/GonkDiskSpaceWatcher.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* 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 "Hal.h"
 #include <sys/syscall.h>
 #include <sys/vfs.h>
 #include <fcntl.h>
 #include <errno.h>
 #include "nsIObserverService.h"
 #include "nsIDiskSpaceWatcher.h"
 #include "mozilla/ModuleUtils.h"
 #include "nsAutoPtr.h"
 #include "nsThreadUtils.h"
 #include "base/message_loop.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/Services.h"
 #include "nsXULAppAPI.h"
 #include "fanotify.h"
 #include "DiskSpaceWatcher.h"
 using namespace mozilla;
 namespace mozilla { namespace hal_impl { class GonkDiskSpaceWatcher; } }
 using namespace mozilla::hal_impl;
 template<>
 struct RunnableMethodTraits<GonkDiskSpaceWatcher>
 {
   static void RetainCallee(GonkDiskSpaceWatcher* obj) { }
   static void ReleaseCallee(GonkDiskSpaceWatcher* obj) { }
 };
 namespace mozilla {
 namespace hal_impl {
 // fanotify_init and fanotify_mark functions are syscalls.
 // The user space bits are not part of bionic so we add them here
 // as well as fanotify.h
 int fanotify_init (unsigned int flags, unsigned int event_f_flags)
 {
   return syscall(367, flags, event_f_flags);
 }
 // Add, remove, or modify an fanotify mark on a filesystem object.
 int fanotify_mark (int fanotify_fd, unsigned int flags,
                    uint64_t mask, int dfd, const char *pathname)
 {
   // On 32 bits platforms we have to convert the 64 bits mask into
   // two 32 bits ints.
   if (sizeof(void *) == 4) {
     union {
       uint64_t _64;
       uint32_t _32[2];
     } _mask;
     _mask._64 = mask;
     return syscall(368, fanotify_fd, flags, _mask._32[0], _mask._32[1],
                    dfd, pathname);
   }
   return syscall(368, fanotify_fd, flags, mask, dfd, pathname);
 }
 class GonkDiskSpaceWatcher MOZ_FINAL : public MessageLoopForIO::Watcher
 {
 public:
   GonkDiskSpaceWatcher();
   ~GonkDiskSpaceWatcher() {};
   virtual void OnFileCanReadWithoutBlocking(int aFd);
   // We should never write to the fanotify fd.
   virtual void OnFileCanWriteWithoutBlocking(int aFd)
   {
     MOZ_CRASH("Must not write to fanotify fd");
   }
   void DoStart();
   void DoStop();
 private:
   void NotifyUpdate();
   uint64_t mLowThreshold;
   uint64_t mHighThreshold;
   TimeDuration mTimeout;
   TimeStamp  mLastTimestamp;
   uint64_t mLastFreeSpace;
   uint32_t mSizeDelta;
   bool mIsDiskFull;
   uint64_t mFreeSpace;
   int mFd;
   MessageLoopForIO::FileDescriptorWatcher mReadWatcher;
 };
 static GonkDiskSpaceWatcher* gHalDiskSpaceWatcher = nullptr;
 #define WATCHER_PREF_LOW        "disk_space_watcher.low_threshold"
 #define WATCHER_PREF_HIGH       "disk_space_watcher.high_threshold"
 #define WATCHER_PREF_TIMEOUT    "disk_space_watcher.timeout"
 #define WATCHER_PREF_SIZE_DELTA "disk_space_watcher.size_delta"
 static const char kWatchedPath[] = "/data";
 // Helper class to dispatch calls to xpcom on the main thread.
 class DiskSpaceNotifier : public nsRunnable
 {
 public:
   DiskSpaceNotifier(const bool aIsDiskFull, const uint64_t aFreeSpace) :
     mIsDiskFull(aIsDiskFull),
     mFreeSpace(aFreeSpace) {}
   NS_IMETHOD Run()
   {
     MOZ_ASSERT(NS_IsMainThread());
     DiskSpaceWatcher::UpdateState(mIsDiskFull, mFreeSpace);
     return NS_OK;
   }
 private:
   bool mIsDiskFull;
   uint64_t mFreeSpace;
 };
 // Helper runnable to delete the watcher on the main thread.
 class DiskSpaceCleaner : public nsRunnable
 {
 public:
   NS_IMETHOD Run()
   {
     MOZ_ASSERT(NS_IsMainThread());
     if (gHalDiskSpaceWatcher) {
       delete gHalDiskSpaceWatcher;
       gHalDiskSpaceWatcher = nullptr;
     }
     return NS_OK;
   }
 };
 GonkDiskSpaceWatcher::GonkDiskSpaceWatcher() :
   mLastFreeSpace(UINT64_MAX),
   mIsDiskFull(false),
   mFreeSpace(UINT64_MAX),
   mFd(-1)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(gHalDiskSpaceWatcher == nullptr);
   // Default values: 5MB for low threshold, 10MB for high threshold, and
   // a timeout of 5 seconds.
   mLowThreshold = Preferences::GetInt(WATCHER_PREF_LOW, 5) * 1024 * 1024;
   mHighThreshold = Preferences::GetInt(WATCHER_PREF_HIGH, 10) * 1024 * 1024;
   mTimeout = TimeDuration::FromSeconds(Preferences::GetInt(WATCHER_PREF_TIMEOUT, 5));
   mSizeDelta = Preferences::GetInt(WATCHER_PREF_SIZE_DELTA, 1) * 1024 * 1024;
 }
 void
 GonkDiskSpaceWatcher::DoStart()
 {
   NS_ASSERTION(XRE_GetIOMessageLoop() == MessageLoopForIO::current(),
                "Not on the correct message loop");
   mFd = fanotify_init(FAN_CLASS_NOTIF, FAN_CLOEXEC);
   if (mFd == -1) {
     NS_WARNING("Error calling inotify_init()");
     if (errno == ENOSYS) {
       printf_stderr("Warning: No fanotify support in this device's kernel.\n");
     }
     return;
   }
   if (fanotify_mark(mFd, FAN_MARK_ADD | FAN_MARK_MOUNT, FAN_CLOSE,
 , kWatchedPath) < 0) {
     NS_WARNING("Error calling fanotify_mark");
     close(mFd);
     mFd = -1;
     return;
   }
   if (!MessageLoopForIO::current()->WatchFileDescriptor(
     mFd, /* persistent = */ true,
     MessageLoopForIO::WATCH_READ,
     &mReadWatcher, gHalDiskSpaceWatcher)) {
       NS_WARNING("Unable to watch fanotify fd.");
       close(mFd);
       mFd = -1;
   }
 }
 void
 GonkDiskSpaceWatcher::DoStop()
 {
   NS_ASSERTION(XRE_GetIOMessageLoop() == MessageLoopForIO::current(),
                "Not on the correct message loop");
   if (mFd != -1) {
     mReadWatcher.StopWatchingFileDescriptor();
     fanotify_mark(mFd, FAN_MARK_FLUSH, 0, 0, kWatchedPath);
     close(mFd);
     mFd = -1;
   }
   // Dispatch the cleanup to the main thread.
   nsCOMPtr<nsIRunnable> runnable = new DiskSpaceCleaner();
   NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL);
 }
 // We are called off the main thread, so we proxy first to the main thread
 // before calling the xpcom object.
 void
 GonkDiskSpaceWatcher::NotifyUpdate()
 {
   mLastTimestamp = TimeStamp::Now();
   mLastFreeSpace = mFreeSpace;
   nsCOMPtr<nsIRunnable> runnable =
     new DiskSpaceNotifier(mIsDiskFull, mFreeSpace);
   NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL);
 }
 void
 GonkDiskSpaceWatcher::OnFileCanReadWithoutBlocking(int aFd)
 {
   struct fanotify_event_metadata* fem = nullptr;
   char buf[4096];
   struct statfs sfs;
   int32_t len, rc;
   do {
     len = read(aFd, buf, sizeof(buf));
   } while(len == -1 && errno == EINTR);
   // Bail out if the file is busy.
   if (len < 0 && errno == ETXTBSY) {
     return;
   }
   // We should get an exact multiple of fanotify_event_metadata
   if (len <= 0 || (len % FAN_EVENT_METADATA_LEN != 0)) {
     printf_stderr("About to crash: fanotify_event_metadata read error.");
     MOZ_CRASH();
   }
   fem = reinterpret_cast<fanotify_event_metadata *>(buf);
   while (FAN_EVENT_OK(fem, len)) {
     rc = fstatfs(fem->fd, &sfs);
     if (rc < 0) {
       NS_WARNING("Unable to stat fan_notify fd");
     } else {
       bool firstRun = mFreeSpace == UINT64_MAX;
       mFreeSpace = sfs.f_bavail * sfs.f_bsize;
       // We change from full <-> free depending on the free space and the
       // low and high thresholds.
       // Once we are in 'full' mode we send updates for all size changes with
       // a minimum of time between messages or when we cross a size change
       // threshold.
       if (firstRun) {
         mIsDiskFull = mFreeSpace <= mLowThreshold;
         // Always notify the current state at first run.
         NotifyUpdate();
       } else if (!mIsDiskFull && (mFreeSpace <= mLowThreshold)) {
         mIsDiskFull = true;
         NotifyUpdate();
       } else if (mIsDiskFull && (mFreeSpace > mHighThreshold)) {
         mIsDiskFull = false;
         NotifyUpdate();
       } else if (mIsDiskFull) {
         if (mTimeout < TimeStamp::Now() - mLastTimestamp ||
             mSizeDelta < llabs(mFreeSpace - mLastFreeSpace)) {
           NotifyUpdate();
         }
       }
     }
     close(fem->fd);
     fem = FAN_EVENT_NEXT(fem, len);
   }
 }
 void
 StartDiskSpaceWatcher()
 {
   MOZ_ASSERT(NS_IsMainThread());
   // Bail out if called several times.
   if (gHalDiskSpaceWatcher != nullptr) {
     return;
   }
   gHalDiskSpaceWatcher = new GonkDiskSpaceWatcher();
   XRE_GetIOMessageLoop()->PostTask(
     FROM_HERE,
     NewRunnableMethod(gHalDiskSpaceWatcher, &GonkDiskSpaceWatcher::DoStart));
 }
 void
 StopDiskSpaceWatcher()
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!gHalDiskSpaceWatcher) {
     return;
   }
   XRE_GetIOMessageLoop()->PostTask(
     FROM_HERE,
     NewRunnableMethod(gHalDiskSpaceWatcher, &GonkDiskSpaceWatcher::DoStop));
 }
 } // namespace hal_impl
 } // namespace mozilla

The Tor Browser / annotate

hal/gonk/GonkDiskSpaceWatcher.cpp@129ffea94266 (annotated)

hal/gonk/GonkDiskSpaceWatcher.cpp