The Tor Browser: xpcom/build/IOInterposer.cpp@129ffea94266 (annotated)

xpcom/build/IOInterposer.cpp@129ffea94266 (annotated)

xpcom/build/IOInterposer.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 <algorithm>
 #include <vector>
 #include "IOInterposer.h"
 #include "IOInterposerPrivate.h"
 #include "MainThreadIOLogger.h"
 #include "mozilla/Atomics.h"
 #include "mozilla/Mutex.h"
 #if defined(MOZILLA_INTERNAL_API)
 // We need to undefine MOZILLA_INTERNAL_API for RefPtr.h because IOInterposer
 // does not clean up its data before shutdown.
 #undef MOZILLA_INTERNAL_API
 #include "mozilla/RefPtr.h"
 #define MOZILLA_INTERNAL_API
 #else
 #include "mozilla/RefPtr.h"
 #endif // defined(MOZILLA_INTERNAL_API)
 #include "mozilla/StaticPtr.h"
 #include "mozilla/ThreadLocal.h"
 #if !defined(XP_WIN)
 #include "NSPRInterposer.h"
 #endif // !defined(XP_WIN)
 #include "nsXULAppAPI.h"
 #include "PoisonIOInterposer.h"
 using namespace mozilla;
 namespace {
 /** Find if a vector contains a specific element */
 template<class T>
 bool VectorContains(const std::vector<T>& vector, const T& element)
 {
   return std::find(vector.begin(), vector.end(), element) != vector.end();
 }
 /** Remove element from a vector */
 template<class T>
 void VectorRemove(std::vector<T>& vector, const T& element)
 {
   typename std::vector<T>::iterator newEnd = std::remove(vector.begin(),
                                                          vector.end(), element);
   vector.erase(newEnd, vector.end());
 }
 /** Lists of Observers */
 struct ObserverLists : public mozilla::AtomicRefCounted<ObserverLists>
 {
   ObserverLists()
   {
   }
   ObserverLists(ObserverLists const & aOther)
     : mCreateObservers(aOther.mCreateObservers)
     , mReadObservers(aOther.mReadObservers)
     , mWriteObservers(aOther.mWriteObservers)
     , mFSyncObservers(aOther.mFSyncObservers)
     , mStatObservers(aOther.mStatObservers)
     , mCloseObservers(aOther.mCloseObservers)
     , mStageObservers(aOther.mStageObservers)
   {
   }
   // Lists of observers for I/O events.
   // These are implemented as vectors since they are allowed to survive gecko,
   // without reporting leaks. This is necessary for the IOInterposer to be used
   // for late-write checks.
   std::vector<IOInterposeObserver*>  mCreateObservers;
   std::vector<IOInterposeObserver*>  mReadObservers;
   std::vector<IOInterposeObserver*>  mWriteObservers;
   std::vector<IOInterposeObserver*>  mFSyncObservers;
   std::vector<IOInterposeObserver*>  mStatObservers;
   std::vector<IOInterposeObserver*>  mCloseObservers;
   std::vector<IOInterposeObserver*>  mStageObservers;
 };
 class PerThreadData
 {
 public:
   PerThreadData(bool aIsMainThread = false)
     : mIsMainThread(aIsMainThread)
     , mIsHandlingObservation(false)
     , mCurrentGeneration(0)
   {
   }
   void
   CallObservers(IOInterposeObserver::Observation& aObservation)
   {
     // Prevent recursive reporting.
     if (mIsHandlingObservation) {
       return;
     }
     mIsHandlingObservation = true;
     // Decide which list of observers to inform
     std::vector<IOInterposeObserver*>* observers = nullptr;
     switch (aObservation.ObservedOperation()) {
       case IOInterposeObserver::OpCreateOrOpen:
         {
           observers = &mObserverLists->mCreateObservers;
         }
         break;
       case IOInterposeObserver::OpRead:
         {
           observers = &mObserverLists->mReadObservers;
         }
         break;
       case IOInterposeObserver::OpWrite:
         {
           observers = &mObserverLists->mWriteObservers;
         }
         break;
       case IOInterposeObserver::OpFSync:
         {
           observers = &mObserverLists->mFSyncObservers;
         }
         break;
       case IOInterposeObserver::OpStat:
         {
           observers = &mObserverLists->mStatObservers;
         }
         break;
       case IOInterposeObserver::OpClose:
         {
           observers = &mObserverLists->mCloseObservers;
         }
         break;
       case IOInterposeObserver::OpNextStage:
         {
           observers = &mObserverLists->mStageObservers;
         }
         break;
       default:
         {
           // Invalid IO operation, see documentation comment for
           // IOInterposer::Report()
           MOZ_ASSERT(false);
           // Just ignore it in non-debug builds.
           return;
         }
     }
     MOZ_ASSERT(observers);
     // Inform observers
     for (std::vector<IOInterposeObserver*>::iterator i = observers->begin(),
          e = observers->end(); i != e; ++i)
     {
       (*i)->Observe(aObservation);
     }
     mIsHandlingObservation = false;
   }
   inline uint32_t
   GetCurrentGeneration() const
   {
     return mCurrentGeneration;
   }
   inline bool
   IsMainThread() const
   {
     return mIsMainThread;
   }
   inline void
   SetObserverLists(uint32_t aNewGeneration, RefPtr<ObserverLists>& aNewLists)
   {
     mCurrentGeneration = aNewGeneration;
     mObserverLists = aNewLists;
   }
 private:
   bool                  mIsMainThread;
   bool                  mIsHandlingObservation;
   uint32_t              mCurrentGeneration;
   RefPtr<ObserverLists> mObserverLists;
 };
 class MasterList
 {
 public:
   MasterList()
     : mObservedOperations(IOInterposeObserver::OpNone)
     , mIsEnabled(true)
   {
   }
   ~MasterList()
   {
   }
   inline void
   Disable()
   {
     mIsEnabled = false;
   }
   void
   Register(IOInterposeObserver::Operation aOp, IOInterposeObserver* aObserver)
   {
     IOInterposer::AutoLock lock(mLock);
     ObserverLists* newLists = nullptr;
     if (mObserverLists) {
       newLists = new ObserverLists(*mObserverLists);
     } else {
       newLists = new ObserverLists();
     }
     // You can register to observe multiple types of observations
     // but you'll never be registered twice for the same observations.
     if (aOp & IOInterposeObserver::OpCreateOrOpen &&
         !VectorContains(newLists->mCreateObservers, aObserver)) {
       newLists->mCreateObservers.push_back(aObserver);
     }
     if (aOp & IOInterposeObserver::OpRead &&
         !VectorContains(newLists->mReadObservers, aObserver)) {
       newLists->mReadObservers.push_back(aObserver);
     }
     if (aOp & IOInterposeObserver::OpWrite &&
         !VectorContains(newLists->mWriteObservers, aObserver)) {
       newLists->mWriteObservers.push_back(aObserver);
     }
     if (aOp & IOInterposeObserver::OpFSync &&
         !VectorContains(newLists->mFSyncObservers, aObserver)) {
       newLists->mFSyncObservers.push_back(aObserver);
     }
     if (aOp & IOInterposeObserver::OpStat &&
         !VectorContains(newLists->mStatObservers, aObserver)) {
       newLists->mStatObservers.push_back(aObserver);
     }
     if (aOp & IOInterposeObserver::OpClose &&
         !VectorContains(newLists->mCloseObservers, aObserver)) {
       newLists->mCloseObservers.push_back(aObserver);
     }
     if (aOp & IOInterposeObserver::OpNextStage &&
         !VectorContains(newLists->mStageObservers, aObserver)) {
       newLists->mStageObservers.push_back(aObserver);
     }
     mObserverLists = newLists;
     mObservedOperations = (IOInterposeObserver::Operation)
                             (mObservedOperations | aOp);
     mCurrentGeneration++;
   }
   void
   Unregister(IOInterposeObserver::Operation aOp, IOInterposeObserver* aObserver)
   {
     IOInterposer::AutoLock lock(mLock);
     ObserverLists* newLists = nullptr;
     if (mObserverLists) {
       newLists = new ObserverLists(*mObserverLists);
     } else {
       newLists = new ObserverLists();
     }
     if (aOp & IOInterposeObserver::OpCreateOrOpen) {
       VectorRemove(newLists->mCreateObservers, aObserver);
       if (newLists->mCreateObservers.empty()) {
         mObservedOperations = (IOInterposeObserver::Operation)
                          (mObservedOperations &
                           ~IOInterposeObserver::OpCreateOrOpen);
       }
     }
     if (aOp & IOInterposeObserver::OpRead) {
       VectorRemove(newLists->mReadObservers, aObserver);
       if (newLists->mReadObservers.empty()) {
         mObservedOperations = (IOInterposeObserver::Operation)
                          (mObservedOperations & ~IOInterposeObserver::OpRead);
       }
     }
     if (aOp & IOInterposeObserver::OpWrite) {
       VectorRemove(newLists->mWriteObservers, aObserver);
       if (newLists->mWriteObservers.empty()) {
         mObservedOperations = (IOInterposeObserver::Operation)
                          (mObservedOperations & ~IOInterposeObserver::OpWrite);
       }
     }
     if (aOp & IOInterposeObserver::OpFSync) {
       VectorRemove(newLists->mFSyncObservers, aObserver);
       if (newLists->mFSyncObservers.empty()) {
         mObservedOperations = (IOInterposeObserver::Operation)
                          (mObservedOperations & ~IOInterposeObserver::OpFSync);
       }
     }
     if (aOp & IOInterposeObserver::OpStat) {
       VectorRemove(newLists->mStatObservers, aObserver);
       if (newLists->mStatObservers.empty()) {
         mObservedOperations = (IOInterposeObserver::Operation)
                          (mObservedOperations & ~IOInterposeObserver::OpStat);
       }
     }
     if (aOp & IOInterposeObserver::OpClose) {
       VectorRemove(newLists->mCloseObservers, aObserver);
       if (newLists->mCloseObservers.empty()) {
         mObservedOperations = (IOInterposeObserver::Operation)
                          (mObservedOperations & ~IOInterposeObserver::OpClose);
       }
     }
     if (aOp & IOInterposeObserver::OpNextStage) {
       VectorRemove(newLists->mStageObservers, aObserver);
       if (newLists->mStageObservers.empty()) {
         mObservedOperations = (IOInterposeObserver::Operation)
                          (mObservedOperations & ~IOInterposeObserver::OpNextStage);
       }
     }
     mObserverLists = newLists;
     mCurrentGeneration++;
   }
   void
   Update(PerThreadData &aPtd)
   {
     if (mCurrentGeneration == aPtd.GetCurrentGeneration()) {
       return;
     }
     // If the generation counts don't match then we need to update the current
     // thread's observer list with the new master list.
     IOInterposer::AutoLock lock(mLock);
     aPtd.SetObserverLists(mCurrentGeneration, mObserverLists);
   }
   inline bool
   IsObservedOperation(IOInterposeObserver::Operation aOp)
   {
     // The quick reader may observe that no locks are being employed here,
     // hence the result of the operations is truly undefined. However, most
     // computers will usually return either true or false, which is good enough.
     // It is not a problem if we occasionally report more or less IO than is
     // actually occurring.
     return mIsEnabled && !!(mObservedOperations & aOp);
   }
 private:
   RefPtr<ObserverLists>             mObserverLists;
   // Note, we cannot use mozilla::Mutex here as the ObserverLists may be leaked
   // (We want to monitor IO during shutdown). Furthermore, as we may have to
   // unregister observers during shutdown an OffTheBooksMutex is not an option
   // either, as its base calls into sDeadlockDetector which may be nullptr
   // during shutdown.
   IOInterposer::Mutex               mLock;
   // Flags tracking which operations are being observed
   IOInterposeObserver::Operation    mObservedOperations;
   // Used for quickly disabling everything by IOInterposer::Disable()
   Atomic<bool>                      mIsEnabled;
   // Used to inform threads that the master observer list has changed
   Atomic<uint32_t>                  mCurrentGeneration;
 };
 // Special observation used by IOInterposer::EnteringNextStage()
 class NextStageObservation : public IOInterposeObserver::Observation
 {
 public:
   NextStageObservation()
     : IOInterposeObserver::Observation(IOInterposeObserver::OpNextStage,
                                        "IOInterposer", false)
   {
     mStart = TimeStamp::Now();
   }
 };
 // List of observers registered
 static StaticAutoPtr<MasterList> sMasterList;
 static ThreadLocal<PerThreadData*> sThreadLocalData;
 } // anonymous namespace
 IOInterposeObserver::Observation::Observation(Operation aOperation,
                                               const char* aReference,
                                               bool aShouldReport)
   : mOperation(aOperation)
   , mReference(aReference)
   , mShouldReport(IOInterposer::IsObservedOperation(aOperation) &&
                   aShouldReport)
 {
   if (mShouldReport) {
     mStart = TimeStamp::Now();
   }
 }
 IOInterposeObserver::Observation::Observation(Operation aOperation,
                                               const TimeStamp& aStart,
                                               const TimeStamp& aEnd,
                                               const char* aReference)
   : mOperation(aOperation)
   , mStart(aStart)
   , mEnd(aEnd)
   , mReference(aReference)
   , mShouldReport(false)
 {
 }
 const char*
 IOInterposeObserver::Observation::ObservedOperationString() const
 {
   switch(mOperation) {
     case OpCreateOrOpen:
       return "create/open";
     case OpRead:
       return "read";
     case OpWrite:
       return "write";
     case OpFSync:
       return "fsync";
     case OpStat:
       return "stat";
     case OpClose:
       return "close";
     case OpNextStage:
       return "NextStage";
     default:
       return "unknown";
   }
 }
 void
 IOInterposeObserver::Observation::Report()
 {
   if (mShouldReport) {
     mEnd = TimeStamp::Now();
     IOInterposer::Report(*this);
   }
 }
 bool
 IOInterposer::Init()
 {
   // Don't initialize twice...
   if (sMasterList) {
     return true;
   }
   if (!sThreadLocalData.init()) {
     return false;
   }
 #if defined(XP_WIN)
   bool isMainThread = XRE_GetWindowsEnvironment() !=
                         WindowsEnvironmentType_Metro;
 #else
   bool isMainThread = true;
 #endif
   RegisterCurrentThread(isMainThread);
   sMasterList = new MasterList();
   MainThreadIOLogger::Init();
   // Now we initialize the various interposers depending on platform
   InitPoisonIOInterposer();
   // We don't hook NSPR on Windows because PoisonIOInterposer captures a
   // superset of the former's events.
 #if !defined(XP_WIN)
   InitNSPRIOInterposing();
 #endif
   return true;
 }
 bool
 IOInterposeObserver::IsMainThread()
 {
   if (!sThreadLocalData.initialized()) {
     return false;
   }
   PerThreadData *ptd = sThreadLocalData.get();
   if (!ptd) {
     return false;
   }
   return ptd->IsMainThread();
 }
 void
 IOInterposer::Clear()
 {
   sMasterList = nullptr;
 }
 void
 IOInterposer::Disable()
 {
   if (!sMasterList) {
     return;
   }
   sMasterList->Disable();
 }
 void
 IOInterposer::Report(IOInterposeObserver::Observation& aObservation)
 {
   MOZ_ASSERT(sMasterList);
   if (!sMasterList) {
     return;
   }
   PerThreadData* ptd = sThreadLocalData.get();
   if (!ptd) {
     // In this case the current thread is not registered with IOInterposer.
     // Alternatively we could take the slow path and just lock everything if
     // we're not registered. That could potentially perform poorly, though.
     return;
   }
   sMasterList->Update(*ptd);
   // Don't try to report if there's nobody listening.
   if (!IOInterposer::IsObservedOperation(aObservation.ObservedOperation())) {
     return;
   }
   ptd->CallObservers(aObservation);
 }
 bool
 IOInterposer::IsObservedOperation(IOInterposeObserver::Operation aOp)
 {
   return sMasterList && sMasterList->IsObservedOperation(aOp);
 }
 void
 IOInterposer::Register(IOInterposeObserver::Operation aOp,
                        IOInterposeObserver* aObserver)
 {
   MOZ_ASSERT(aObserver);
   if (!sMasterList || !aObserver) {
     return;
   }
   sMasterList->Register(aOp, aObserver);
 }
 void
 IOInterposer::Unregister(IOInterposeObserver::Operation aOp,
                          IOInterposeObserver* aObserver)
 {
   if (!sMasterList) {
     return;
   }
   sMasterList->Unregister(aOp, aObserver);
 }
 void
 IOInterposer::RegisterCurrentThread(bool aIsMainThread)
 {
   if (!sThreadLocalData.initialized()) {
     return;
   }
   MOZ_ASSERT(!sThreadLocalData.get());
   PerThreadData* curThreadData = new PerThreadData(aIsMainThread);
   sThreadLocalData.set(curThreadData);
 }
 void
 IOInterposer::UnregisterCurrentThread()
 {
   if (!sThreadLocalData.initialized()) {
     return;
   }
   PerThreadData* curThreadData = sThreadLocalData.get();
   MOZ_ASSERT(curThreadData);
   sThreadLocalData.set(nullptr);
   delete curThreadData;
 }
 void
 IOInterposer::EnteringNextStage()
 {
   if (!sMasterList) {
     return;
   }
   NextStageObservation observation;
   Report(observation);
 }

The Tor Browser / annotate

xpcom/build/IOInterposer.cpp@129ffea94266 (annotated)

xpcom/build/IOInterposer.cpp