gecko-dev/xpcom/build/NSPRInterposer.cpp

186 строки
5.5 KiB
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 "IOInterposer.h"
#include "NSPRInterposer.h"
#include "prio.h"
#include "private/pprio.h"
#include "nsDebug.h"
#include "nscore.h"
namespace {
using namespace mozilla;
/* Original IO methods */
PRCloseFN sCloseFn = nullptr;
PRReadFN sReadFn = nullptr;
PRWriteFN sWriteFn = nullptr;
PRFsyncFN sFSyncFn = nullptr;
PRFileInfoFN sFileInfoFn = nullptr;
PRFileInfo64FN sFileInfo64Fn = nullptr;
/**
* RAII class for timing the duration of an NSPR I/O call and reporting the
* result to the IOInterposeObserver API.
*/
class NSPRIOAutoObservation : public IOInterposeObserver::Observation
{
public:
explicit NSPRIOAutoObservation(IOInterposeObserver::Operation aOp)
: IOInterposeObserver::Observation(aOp, "NSPRIOInterposer")
{
}
~NSPRIOAutoObservation() override
{
Report();
}
};
PRStatus PR_CALLBACK
interposedClose(PRFileDesc* aFd)
{
// If we don't have a valid original function pointer something is very wrong.
NS_ASSERTION(sCloseFn, "NSPR IO Interposing: sCloseFn is NULL");
NSPRIOAutoObservation timer(IOInterposeObserver::OpClose);
return sCloseFn(aFd);
}
int32_t PR_CALLBACK
interposedRead(PRFileDesc* aFd, void* aBuf, int32_t aAmt)
{
// If we don't have a valid original function pointer something is very wrong.
NS_ASSERTION(sReadFn, "NSPR IO Interposing: sReadFn is NULL");
NSPRIOAutoObservation timer(IOInterposeObserver::OpRead);
return sReadFn(aFd, aBuf, aAmt);
}
int32_t PR_CALLBACK
interposedWrite(PRFileDesc* aFd, const void* aBuf, int32_t aAmt)
{
// If we don't have a valid original function pointer something is very wrong.
NS_ASSERTION(sWriteFn, "NSPR IO Interposing: sWriteFn is NULL");
NSPRIOAutoObservation timer(IOInterposeObserver::OpWrite);
return sWriteFn(aFd, aBuf, aAmt);
}
PRStatus PR_CALLBACK
interposedFSync(PRFileDesc* aFd)
{
// If we don't have a valid original function pointer something is very wrong.
NS_ASSERTION(sFSyncFn, "NSPR IO Interposing: sFSyncFn is NULL");
NSPRIOAutoObservation timer(IOInterposeObserver::OpFSync);
return sFSyncFn(aFd);
}
PRStatus PR_CALLBACK
interposedFileInfo(PRFileDesc* aFd, PRFileInfo* aInfo)
{
// If we don't have a valid original function pointer something is very wrong.
NS_ASSERTION(sFileInfoFn, "NSPR IO Interposing: sFileInfoFn is NULL");
NSPRIOAutoObservation timer(IOInterposeObserver::OpStat);
return sFileInfoFn(aFd, aInfo);
}
PRStatus PR_CALLBACK
interposedFileInfo64(PRFileDesc* aFd, PRFileInfo64* aInfo)
{
// If we don't have a valid original function pointer something is very wrong.
NS_ASSERTION(sFileInfo64Fn, "NSPR IO Interposing: sFileInfo64Fn is NULL");
NSPRIOAutoObservation timer(IOInterposeObserver::OpStat);
return sFileInfo64Fn(aFd, aInfo);
}
} // namespace
namespace mozilla {
void
InitNSPRIOInterposing()
{
// Check that we have not interposed any of the IO methods before
MOZ_ASSERT(!sCloseFn && !sReadFn && !sWriteFn && !sFSyncFn && !sFileInfoFn &&
!sFileInfo64Fn);
// We can't actually use this assertion because we initialize this code
// before XPCOM is initialized, so NS_IsMainThread() always returns false.
// MOZ_ASSERT(NS_IsMainThread());
// Get IO methods from NSPR and const cast the structure so we can modify it.
PRIOMethods* methods = const_cast<PRIOMethods*>(PR_GetFileMethods());
// Something is badly wrong if we don't get IO methods... However, we don't
// want to crash over that in non-debug builds. This is unlikely to happen
// so an assert is enough, no need to report it to the caller.
MOZ_ASSERT(methods);
if (!methods) {
return;
}
// Store original functions
sCloseFn = methods->close;
sReadFn = methods->read;
sWriteFn = methods->write;
sFSyncFn = methods->fsync;
sFileInfoFn = methods->fileInfo;
sFileInfo64Fn = methods->fileInfo64;
// Overwrite with our interposed functions
methods->close = &interposedClose;
methods->read = &interposedRead;
methods->write = &interposedWrite;
methods->fsync = &interposedFSync;
methods->fileInfo = &interposedFileInfo;
methods->fileInfo64 = &interposedFileInfo64;
}
void
ClearNSPRIOInterposing()
{
// If we have already cleared IO interposing, or not initialized it this is
// actually bad.
MOZ_ASSERT(sCloseFn && sReadFn && sWriteFn && sFSyncFn && sFileInfoFn &&
sFileInfo64Fn);
// Get IO methods from NSPR and const cast the structure so we can modify it.
PRIOMethods* methods = const_cast<PRIOMethods*>(PR_GetFileMethods());
// Something is badly wrong if we don't get IO methods... However, we don't
// want to crash over that in non-debug builds. This is unlikely to happen
// so an assert is enough, no need to report it to the caller.
MOZ_ASSERT(methods);
if (!methods) {
return;
}
// Restore original functions
methods->close = sCloseFn;
methods->read = sReadFn;
methods->write = sWriteFn;
methods->fsync = sFSyncFn;
methods->fileInfo = sFileInfoFn;
methods->fileInfo64 = sFileInfo64Fn;
// Forget about original functions
sCloseFn = nullptr;
sReadFn = nullptr;
sWriteFn = nullptr;
sFSyncFn = nullptr;
sFileInfoFn = nullptr;
sFileInfo64Fn = nullptr;
}
} // namespace mozilla