Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/C/Firefox/xpcom/build/ (Browser von der Mozilla Stiftung Version 136.0.1^©) Datei vom 10.2.2025 mit Größe 17 kB

Quelle IOInterposer.cpp Sprache: C

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=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 <algorithm>
#include <vector>

#include "IOInterposer.h"

#include "IOInterposerPrivate.h"
#include "MainThreadIOLogger.h"
#include "mozilla/Atomics.h"
#include "mozilla/Mutex.h"
#include "mozilla/RefPtr.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/ThreadLocal.h"
#include "nscore.h"  // for NS_FREE_PERMANENT_DATA
#if !defined(XP_WIN)
#  include "NSPRInterposer.h"
#endif  // !defined(XP_WIN)
#include "nsXULAppAPI.h"
#include "PoisonIOInterposer.h"
#include "prenv.h"

namespace {

/** Find if a vector contains a specific element */
template <class T>
bool VectorContains(const std::vector<T>& aVector, const T& aElement) {
  return std::find(aVector.begin(), aVector.end(), aElement) != aVector.end();
}

/** Remove element from a vector */
template <class T>
void VectorRemove(std::vector<T>& aVector, const T& aElement) {
  typename std::vector<T>::iterator newEnd =
      std::remove(aVector.begin(), aVector.end(), aElement);
  aVector.erase(newEnd, aVector.end());
}

/** Lists of Observers */
struct ObserverLists {
private:
  ~ObserverLists() = default;

public:
  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ObserverLists)

  ObserverLists() = default;

  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<mozilla::IOInterposeObserver*> mCreateObservers;
  std::vector<mozilla::IOInterposeObserver*> mReadObservers;
  std::vector<mozilla::IOInterposeObserver*> mWriteObservers;
  std::vector<mozilla::IOInterposeObserver*> mFSyncObservers;
  std::vector<mozilla::IOInterposeObserver*> mStatObservers;
  std::vector<mozilla::IOInterposeObserver*> mCloseObservers;
  std::vector<mozilla::IOInterposeObserver*> mStageObservers;
};

class PerThreadData {
public:
  explicit PerThreadData(bool aIsMainThread = false)
      : mIsMainThread(aIsMainThread),
        mIsHandlingObservation(false),
        mCurrentGeneration(0) {
    MOZ_COUNT_CTOR(PerThreadData);
  }

  MOZ_COUNTED_DTOR(PerThreadData)

  void CallObservers(mozilla::IOInterposeObserver::Observation& aObservation) {
    // Prevent recursive reporting.
    if (mIsHandlingObservation) {
      return;
    }

    mIsHandlingObservation = true;
    // Decide which list of observers to inform
    const std::vector<mozilla::IOInterposeObserver*>* observers = nullptr;
    switch (aObservation.ObservedOperation()) {
      case mozilla::IOInterposeObserver::OpCreateOrOpen:
        observers = &mObserverLists->mCreateObservers;
        break;
      case mozilla::IOInterposeObserver::OpRead:
        observers = &mObserverLists->mReadObservers;
        break;
      case mozilla::IOInterposeObserver::OpWrite:
        observers = &mObserverLists->mWriteObservers;
        break;
      case mozilla::IOInterposeObserver::OpFSync:
        observers = &mObserverLists->mFSyncObservers;
        break;
      case mozilla::IOInterposeObserver::OpStat:
        observers = &mObserverLists->mStatObservers;
        break;
      case mozilla::IOInterposeObserver::OpClose:
        observers = &mObserverLists->mCloseObservers;
        break;
      case mozilla::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 (auto 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<const ObserverLists>& aNewLists) {
    mCurrentGeneration = aNewGeneration;
    mObserverLists = aNewLists;
  }

  inline void ClearObserverLists() {
    if (mObserverLists) {
      mCurrentGeneration = 0;
      mObserverLists = nullptr;
    }
  }

private:
  bool mIsMainThread;
  bool mIsHandlingObservation;
  uint32_t mCurrentGeneration;
  RefPtr<const ObserverLists> mObserverLists;
};

// Thread-safe list of observers, from which `PerThreadData` sources its own
// local list when needed.
class SourceList {
public:
  SourceList()
      : mObservedOperations(mozilla::IOInterposeObserver::OpNone),
        mIsEnabled(true) {
    MOZ_COUNT_CTOR(SourceList);
  }

  MOZ_COUNTED_DTOR(SourceList)

  inline void Disable() { mIsEnabled = false; }
  inline void Enable() { mIsEnabled = true; }

  void Register(mozilla::IOInterposeObserver::Operation aOp,
                mozilla::IOInterposeObserver* aStaticObserver) {
    mozilla::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 & mozilla::IOInterposeObserver::OpCreateOrOpen &&
        !VectorContains(newLists->mCreateObservers, aStaticObserver)) {
      newLists->mCreateObservers.push_back(aStaticObserver);
    }
    if (aOp & mozilla::IOInterposeObserver::OpRead &&
        !VectorContains(newLists->mReadObservers, aStaticObserver)) {
      newLists->mReadObservers.push_back(aStaticObserver);
    }
    if (aOp & mozilla::IOInterposeObserver::OpWrite &&
        !VectorContains(newLists->mWriteObservers, aStaticObserver)) {
      newLists->mWriteObservers.push_back(aStaticObserver);
    }
    if (aOp & mozilla::IOInterposeObserver::OpFSync &&
        !VectorContains(newLists->mFSyncObservers, aStaticObserver)) {
      newLists->mFSyncObservers.push_back(aStaticObserver);
    }
    if (aOp & mozilla::IOInterposeObserver::OpStat &&
        !VectorContains(newLists->mStatObservers, aStaticObserver)) {
      newLists->mStatObservers.push_back(aStaticObserver);
    }
    if (aOp & mozilla::IOInterposeObserver::OpClose &&
        !VectorContains(newLists->mCloseObservers, aStaticObserver)) {
      newLists->mCloseObservers.push_back(aStaticObserver);
    }
    if (aOp & mozilla::IOInterposeObserver::OpNextStage &&
        !VectorContains(newLists->mStageObservers, aStaticObserver)) {
      newLists->mStageObservers.push_back(aStaticObserver);
    }
    mObserverLists = newLists;
    mObservedOperations =
        (mozilla::IOInterposeObserver::Operation)(mObservedOperations | aOp);

    mCurrentGeneration++;
  }

  void Unregister(mozilla::IOInterposeObserver::Operation aOp,
                  mozilla::IOInterposeObserver* aStaticObserver) {
    mozilla::IOInterposer::AutoLock lock(mLock);

    ObserverLists* newLists = nullptr;
    if (mObserverLists) {
      newLists = new ObserverLists(*mObserverLists);
    } else {
      newLists = new ObserverLists();
    }

    if (aOp & mozilla::IOInterposeObserver::OpCreateOrOpen) {
      VectorRemove(newLists->mCreateObservers, aStaticObserver);
      if (newLists->mCreateObservers.empty()) {
        mObservedOperations = (mozilla::IOInterposeObserver::Operation)(
            mObservedOperations &
            ~mozilla::IOInterposeObserver::OpCreateOrOpen);
      }
    }
    if (aOp & mozilla::IOInterposeObserver::OpRead) {
      VectorRemove(newLists->mReadObservers, aStaticObserver);
      if (newLists->mReadObservers.empty()) {
        mObservedOperations = (mozilla::IOInterposeObserver::Operation)(
            mObservedOperations & ~mozilla::IOInterposeObserver::OpRead);
      }
    }
    if (aOp & mozilla::IOInterposeObserver::OpWrite) {
      VectorRemove(newLists->mWriteObservers, aStaticObserver);
      if (newLists->mWriteObservers.empty()) {
        mObservedOperations = (mozilla::IOInterposeObserver::Operation)(
            mObservedOperations & ~mozilla::IOInterposeObserver::OpWrite);
      }
    }
    if (aOp & mozilla::IOInterposeObserver::OpFSync) {
      VectorRemove(newLists->mFSyncObservers, aStaticObserver);
      if (newLists->mFSyncObservers.empty()) {
        mObservedOperations = (mozilla::IOInterposeObserver::Operation)(
            mObservedOperations & ~mozilla::IOInterposeObserver::OpFSync);
      }
    }
    if (aOp & mozilla::IOInterposeObserver::OpStat) {
      VectorRemove(newLists->mStatObservers, aStaticObserver);
      if (newLists->mStatObservers.empty()) {
        mObservedOperations = (mozilla::IOInterposeObserver::Operation)(
            mObservedOperations & ~mozilla::IOInterposeObserver::OpStat);
      }
    }
    if (aOp & mozilla::IOInterposeObserver::OpClose) {
      VectorRemove(newLists->mCloseObservers, aStaticObserver);
      if (newLists->mCloseObservers.empty()) {
        mObservedOperations = (mozilla::IOInterposeObserver::Operation)(
            mObservedOperations & ~mozilla::IOInterposeObserver::OpClose);
      }
    }
    if (aOp & mozilla::IOInterposeObserver::OpNextStage) {
      VectorRemove(newLists->mStageObservers, aStaticObserver);
      if (newLists->mStageObservers.empty()) {
        mObservedOperations = (mozilla::IOInterposeObserver::Operation)(
            mObservedOperations & ~mozilla::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 source list.
    mozilla::IOInterposer::AutoLock lock(mLock);
    aPtd.SetObserverLists(mCurrentGeneration, mObserverLists);
  }

  inline bool IsObservedOperation(mozilla::IOInterposeObserver::Operation aOp) {
    // This does not occur inside of a lock, so this makes no guarantees that
    // the observers are in sync with this. That is acceptable; it is not a
    // problem if we occasionally report more or less IO than is actually
    // occurring.
    return mIsEnabled && !!(mObservedOperations & aOp);
  }

private:
  RefPtr<const ObserverLists> mObserverLists MOZ_GUARDED_BY(mLock);
  // 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.
  mozilla::IOInterposer::Mutex mLock;
  // Flags tracking which operations are being observed
  mozilla::Atomic<mozilla::IOInterposeObserver::Operation,
                  mozilla::MemoryOrdering::Relaxed>
      mObservedOperations;
  // Used for quickly disabling everything by IOInterposer::Disable()
  mozilla::Atomic<bool> mIsEnabled;
  // Used to inform threads that the source observer list has changed
  mozilla::Atomic<uint32_t> mCurrentGeneration;
};

// Special observation used by IOInterposer::EnteringNextStage()
class NextStageObservation : public mozilla::IOInterposeObserver::Observation {
public:
  NextStageObservation()
      : mozilla::IOInterposeObserver::Observation(
            mozilla::IOInterposeObserver::OpNextStage, "IOInterposer", false) {
    mStart = mozilla::TimeStamp::Now();
    mEnd = mStart;
  }
};

// List of observers registered
static mozilla::StaticAutoPtr<SourceList> sSourceList;
static MOZ_THREAD_LOCAL(PerThreadData*) sThreadLocalData;
static bool sThreadLocalDataInitialized;

}  // anonymous namespace

namespace mozilla {

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 (sSourceList) {
    return true;
  }
  if (!sThreadLocalData.init()) {
    return false;
  }
  sThreadLocalDataInitialized = true;
  bool isMainThread = true;
  RegisterCurrentThread(isMainThread);
  sSourceList = new SourceList();

  MainThreadIOLogger::Init();

  // Now we initialize the various interposers depending on platform

  // Under certain conditions it may be unsafe to initialize PoisonIOInterposer,
  // such as when a background thread is already running. We set this variable
  // elsewhere when such a condition applies.
  if (!PR_GetEnv("MOZ_DISABLE_POISON_IO_INTERPOSER")) {
    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 (!sThreadLocalDataInitialized) {
    return false;
  }
  PerThreadData* ptd = sThreadLocalData.get();
  if (!ptd) {
    return false;
  }
  return ptd->IsMainThread();
}

void IOInterposer::Clear() {
  /* Clear() is a no-op on release builds so that we may continue to trap I/O
     until process termination. In leak-checking builds, we need to shut down
     IOInterposer so that all references are properly released. */
#ifdef NS_FREE_PERMANENT_DATA
  UnregisterCurrentThread();
  sSourceList = nullptr;
#endif
}

void IOInterposer::Disable() {
  if (!sSourceList) {
    return;
  }
  sSourceList->Disable();
}

void IOInterposer::Enable() {
  if (!sSourceList) {
    return;
  }
  sSourceList->Enable();
}

void IOInterposer::Report(IOInterposeObserver::Observation& aObservation) {
  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;
  }

  if (!sSourceList) {
    // If there is no longer a source list then we should clear the local one.
    ptd->ClearObserverLists();
    return;
  }

  sSourceList->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 sSourceList && sSourceList->IsObservedOperation(aOp);
}

void IOInterposer::Register(IOInterposeObserver::Operation aOp,
                            IOInterposeObserver* aStaticObserver) {
  MOZ_ASSERT(aStaticObserver);
  if (!sSourceList || !aStaticObserver) {
    return;
  }

  sSourceList->Register(aOp, aStaticObserver);
}

void IOInterposer::Unregister(IOInterposeObserver::Operation aOp,
                              IOInterposeObserver* aStaticObserver) {
  if (!sSourceList) {
    return;
  }

  sSourceList->Unregister(aOp, aStaticObserver);
}

void IOInterposer::RegisterCurrentThread(bool aIsMainThread) {
  if (!sThreadLocalDataInitialized) {
    return;
  }
  MOZ_ASSERT(!sThreadLocalData.get());
  PerThreadData* curThreadData = new PerThreadData(aIsMainThread);
  sThreadLocalData.set(curThreadData);
}

void IOInterposer::UnregisterCurrentThread() {
  if (!sThreadLocalDataInitialized) {
    return;
  }
  if (PerThreadData* curThreadData = sThreadLocalData.get()) {
    sThreadLocalData.set(nullptr);
    delete curThreadData;
  }
}

void IOInterposer::EnteringNextStage() {
  if (!sSourceList) {
    return;
  }
  NextStageObservation observation;
  Report(observation);
}

}  // namespace mozilla

quality100%

¤ Dauer der Verarbeitung: 0.3 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.