gecko-dev/xpcom/build/PoisonIOInterposerBase.cpp
Jonas Finnemann Jensen 41edf8980c Bug 902587 - Part 2A: Refactor late-write-checks as client of IO Interposer. r=BenWa
--HG--
rename : xpcom/build/mozPoisonWrite.h => xpcom/build/LateWriteChecks.h
rename : xpcom/build/mozPoisonWrite.h => xpcom/build/PoisonIOInterposer.h
rename : xpcom/build/mozPoisonWriteBase.cpp => xpcom/build/PoisonIOInterposerBase.cpp
rename : xpcom/build/mozPoisonWriteMac.cpp => xpcom/build/PoisonIOInterposerMac.cpp
rename : xpcom/build/mozPoisonWriteWin.cpp => xpcom/build/PoisonIOInterposerWin.cpp
2013-11-05 07:45:20 -05:00

150 lines
4.1 KiB
C++

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 ci et: */
/* 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 "mozilla/Mutex.h"
#include "mozilla/Scoped.h"
#include <algorithm>
#include <vector>
#include "PoisonIOInterposer.h"
// Auxiliary method to convert file descriptors to ids
#if defined(XP_WIN32)
#include <io.h>
inline intptr_t FileDescriptorToID(int aFd) {
return _get_osfhandle(aFd);
}
#else
inline intptr_t FileDescriptorToID(int aFd) {
return aFd;
}
#endif /* if not XP_WIN32 */
using namespace mozilla;
namespace {
struct DebugFilesAutoLockTraits {
typedef PRLock *type;
const static type empty() {
return nullptr;
}
const static void release(type aL) {
PR_Unlock(aL);
}
};
class DebugFilesAutoLock : public Scoped<DebugFilesAutoLockTraits> {
static PRLock *Lock;
public:
static void Clear();
static PRLock *getDebugFileIDsLock() {
// On windows this static is not thread safe, but we know that the first
// call is from
// * An early registration of a debug FD or
// * The call to InitWritePoisoning.
// Since the early debug FDs are logs created early in the main thread
// and no writes are trapped before InitWritePoisoning, we are safe.
if (!Lock) {
Lock = PR_NewLock();
}
// We have to use something lower level than a mutex. If we don't, we
// can get recursive in here when called from logging a call to free.
return Lock;
}
DebugFilesAutoLock() :
Scoped<DebugFilesAutoLockTraits>(getDebugFileIDsLock()) {
PR_Lock(get());
}
};
PRLock *DebugFilesAutoLock::Lock;
void DebugFilesAutoLock::Clear() {
MOZ_ASSERT(Lock != nullptr);
Lock = nullptr;
}
// Return a vector used to hold the IDs of the current debug files. On unix
// an ID is a file descriptor. On Windows it is a file HANDLE.
std::vector<intptr_t>* getDebugFileIDs() {
PR_ASSERT_CURRENT_THREAD_OWNS_LOCK(DebugFilesAutoLock::getDebugFileIDsLock());
// We have to use new as some write happen during static destructors
// so an static std::vector might be destroyed while we still need it.
static std::vector<intptr_t> *DebugFileIDs = new std::vector<intptr_t>();
return DebugFileIDs;
}
} // anonymous namespace
namespace mozilla{
// Auxiliary Method to test if a file descriptor is registered to be ignored
// by the poisoning IO interposer
bool IsDebugFile(intptr_t aFileID) {
DebugFilesAutoLock lockedScope;
std::vector<intptr_t> &Vec = *getDebugFileIDs();
return std::find(Vec.begin(), Vec.end(), aFileID) != Vec.end();
}
// Clean-up for the registered debug files.
// We should probably make sure all debug files are unregistered instead.
// But as the poison IO interposer is used for late-write checks we're not
// disabling it at any point yet. So Really no need for this.
//
// void ClearDebugFileRegister() {
// PRLock *Lock;
// {
// DebugFilesAutoLock lockedScope;
// delete getDebugFileIDs();
// Lock = DebugFilesAutoLock::getDebugFileIDsLock();
// DebugFilesAutoLock::Clear();
// }
// PR_DestroyLock(Lock);
// }
} // namespace mozilla
extern "C" {
void MozillaRegisterDebugFD(int fd) {
intptr_t fileId = FileDescriptorToID(fd);
DebugFilesAutoLock lockedScope;
std::vector<intptr_t> &Vec = *getDebugFileIDs();
MOZ_ASSERT(std::find(Vec.begin(), Vec.end(), fileId) == Vec.end());
Vec.push_back(fileId);
}
void MozillaRegisterDebugFILE(FILE *f) {
int fd = fileno(f);
if (fd == 1 || fd == 2) {
return;
}
MozillaRegisterDebugFD(fd);
}
void MozillaUnRegisterDebugFD(int fd) {
DebugFilesAutoLock lockedScope;
intptr_t fileId = FileDescriptorToID(fd);
std::vector<intptr_t> &Vec = *getDebugFileIDs();
std::vector<intptr_t>::iterator i =
std::find(Vec.begin(), Vec.end(), fileId);
MOZ_ASSERT(i != Vec.end());
Vec.erase(i);
}
void MozillaUnRegisterDebugFILE(FILE *f) {
int fd = fileno(f);
if (fd == 1 || fd == 2) {
return;
}
fflush(f);
MozillaUnRegisterDebugFD(fd);
}
}