The Tor Browser: comparison xpcom/build/IOInterposer.cpp

--1:000000000000
+:a6c467cb5848
+/* 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 / file comparison

comparison: xpcom/build/IOInterposer.cpp

xpcom/build/IOInterposer.cpp