mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-09 20:54:40 +00:00
888 lines
25 KiB
C++
888 lines
25 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
* vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
|
|
* 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 <string.h>
|
|
#include "mozilla/Telemetry.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "sqlite3.h"
|
|
#include "nsThreadUtils.h"
|
|
#include "mozilla/dom/quota/PersistenceType.h"
|
|
#include "mozilla/dom/quota/QuotaManager.h"
|
|
#include "mozilla/dom/quota/QuotaObject.h"
|
|
#include "mozilla/IOInterposer.h"
|
|
|
|
// The last VFS version for which this file has been updated.
|
|
#define LAST_KNOWN_VFS_VERSION 3
|
|
|
|
// The last io_methods version for which this file has been updated.
|
|
#define LAST_KNOWN_IOMETHODS_VERSION 3
|
|
|
|
/**
|
|
* This preference is a workaround to allow users/sysadmins to identify
|
|
* that the profile exists on an NFS share whose implementation
|
|
* is incompatible with SQLite's default locking implementation.
|
|
* Bug 433129 attempted to automatically identify such file-systems,
|
|
* but a reliable way was not found and it was determined that the fallback
|
|
* locking is slower than POSIX locking, so we do not want to do it by default.
|
|
*/
|
|
#define PREF_NFS_FILESYSTEM "storage.nfs_filesystem"
|
|
|
|
namespace {
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom::quota;
|
|
|
|
struct Histograms {
|
|
const char *name;
|
|
const Telemetry::ID readB;
|
|
const Telemetry::ID writeB;
|
|
const Telemetry::ID readMS;
|
|
const Telemetry::ID writeMS;
|
|
const Telemetry::ID syncMS;
|
|
};
|
|
|
|
#define SQLITE_TELEMETRY(FILENAME, HGRAM) \
|
|
{ FILENAME, \
|
|
Telemetry::MOZ_SQLITE_ ## HGRAM ## _READ_B, \
|
|
Telemetry::MOZ_SQLITE_ ## HGRAM ## _WRITE_B, \
|
|
Telemetry::MOZ_SQLITE_ ## HGRAM ## _READ_MS, \
|
|
Telemetry::MOZ_SQLITE_ ## HGRAM ## _WRITE_MS, \
|
|
Telemetry::MOZ_SQLITE_ ## HGRAM ## _SYNC_MS \
|
|
}
|
|
|
|
Histograms gHistograms[] = {
|
|
SQLITE_TELEMETRY("places.sqlite", PLACES),
|
|
SQLITE_TELEMETRY("cookies.sqlite", COOKIES),
|
|
SQLITE_TELEMETRY("webappsstore.sqlite", WEBAPPS),
|
|
SQLITE_TELEMETRY(nullptr, OTHER)
|
|
};
|
|
#undef SQLITE_TELEMETRY
|
|
|
|
/** RAII class for measuring how long io takes on/off main thread
|
|
*/
|
|
class IOThreadAutoTimer {
|
|
public:
|
|
/**
|
|
* IOThreadAutoTimer measures time spent in IO. Additionally it
|
|
* automatically determines whether IO is happening on the main
|
|
* thread and picks an appropriate histogram.
|
|
*
|
|
* @param id takes a telemetry histogram id. The id+1 must be an
|
|
* equivalent histogram for the main thread. Eg, MOZ_SQLITE_OPEN_MS
|
|
* is followed by MOZ_SQLITE_OPEN_MAIN_THREAD_MS.
|
|
*
|
|
* @param aOp optionally takes an IO operation to report through the
|
|
* IOInterposer. Filename will be reported as NULL, and reference will be
|
|
* either "sqlite-mainthread" or "sqlite-otherthread".
|
|
*/
|
|
explicit IOThreadAutoTimer(Telemetry::ID id,
|
|
IOInterposeObserver::Operation aOp = IOInterposeObserver::OpNone)
|
|
: start(TimeStamp::Now()),
|
|
id(id),
|
|
op(aOp)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* This constructor is for when we want to report an operation to
|
|
* IOInterposer but do not require a telemetry probe.
|
|
*
|
|
* @param aOp IO Operation to report through the IOInterposer.
|
|
*/
|
|
explicit IOThreadAutoTimer(IOInterposeObserver::Operation aOp)
|
|
: start(TimeStamp::Now()),
|
|
id(Telemetry::HistogramCount),
|
|
op(aOp)
|
|
{
|
|
}
|
|
|
|
~IOThreadAutoTimer()
|
|
{
|
|
TimeStamp end(TimeStamp::Now());
|
|
uint32_t mainThread = NS_IsMainThread() ? 1 : 0;
|
|
if (id != Telemetry::HistogramCount) {
|
|
Telemetry::AccumulateTimeDelta(static_cast<Telemetry::ID>(id + mainThread),
|
|
start, end);
|
|
}
|
|
// We don't report SQLite I/O on Windows because we have a comprehensive
|
|
// mechanism for intercepting I/O on that platform that captures a superset
|
|
// of the data captured here.
|
|
#if defined(MOZ_ENABLE_PROFILER_SPS) && !defined(XP_WIN)
|
|
if (IOInterposer::IsObservedOperation(op)) {
|
|
const char* main_ref = "sqlite-mainthread";
|
|
const char* other_ref = "sqlite-otherthread";
|
|
|
|
// Create observation
|
|
IOInterposeObserver::Observation ob(op, start, end,
|
|
(mainThread ? main_ref : other_ref));
|
|
// Report observation
|
|
IOInterposer::Report(ob);
|
|
}
|
|
#endif /* defined(MOZ_ENABLE_PROFILER_SPS) && !defined(XP_WIN) */
|
|
}
|
|
|
|
private:
|
|
const TimeStamp start;
|
|
const Telemetry::ID id;
|
|
IOInterposeObserver::Operation op;
|
|
};
|
|
|
|
struct telemetry_file {
|
|
// Base class. Must be first
|
|
sqlite3_file base;
|
|
|
|
// histograms pertaining to this file
|
|
Histograms *histograms;
|
|
|
|
// quota object for this file
|
|
RefPtr<QuotaObject> quotaObject;
|
|
|
|
// The chunk size for this file. See the documentation for
|
|
// sqlite3_file_control() and FCNTL_CHUNK_SIZE.
|
|
int fileChunkSize;
|
|
|
|
// This contains the vfs that actually does work
|
|
sqlite3_file pReal[1];
|
|
};
|
|
|
|
const char*
|
|
DatabasePathFromWALPath(const char *zWALName)
|
|
{
|
|
/**
|
|
* Do some sketchy pointer arithmetic to find the parameter key. The WAL
|
|
* filename is in the middle of a big allocated block that contains:
|
|
*
|
|
* - Random Values
|
|
* - Main Database Path
|
|
* - \0
|
|
* - Multiple URI components consisting of:
|
|
* - Key
|
|
* - \0
|
|
* - Value
|
|
* - \0
|
|
* - \0
|
|
* - Journal Path
|
|
* - \0
|
|
* - WAL Path (zWALName)
|
|
* - \0
|
|
*
|
|
* Because the main database path is preceded by a random value we have to be
|
|
* careful when trying to figure out when we should terminate this loop.
|
|
*/
|
|
MOZ_ASSERT(zWALName);
|
|
|
|
nsDependentCSubstring dbPath(zWALName, strlen(zWALName));
|
|
|
|
// Chop off the "-wal" suffix.
|
|
NS_NAMED_LITERAL_CSTRING(kWALSuffix, "-wal");
|
|
MOZ_ASSERT(StringEndsWith(dbPath, kWALSuffix));
|
|
|
|
dbPath.Rebind(zWALName, dbPath.Length() - kWALSuffix.Length());
|
|
MOZ_ASSERT(!dbPath.IsEmpty());
|
|
|
|
// We want to scan to the end of the key/value URI pairs. Skip the preceding
|
|
// null and go to the last char of the journal path.
|
|
const char* cursor = zWALName - 2;
|
|
|
|
// Make sure we just skipped a null.
|
|
MOZ_ASSERT(!*(cursor + 1));
|
|
|
|
// Walk backwards over the journal path.
|
|
while (*cursor) {
|
|
cursor--;
|
|
}
|
|
|
|
// There should be another null here.
|
|
cursor--;
|
|
MOZ_ASSERT(!*cursor);
|
|
|
|
// Back up one more char to the last char of the previous string. It may be
|
|
// the database path or it may be a key/value URI pair.
|
|
cursor--;
|
|
|
|
#ifdef DEBUG
|
|
{
|
|
// Verify that we just walked over the journal path. Account for the two
|
|
// nulls we just skipped.
|
|
const char *journalStart = cursor + 3;
|
|
|
|
nsDependentCSubstring journalPath(journalStart,
|
|
strlen(journalStart));
|
|
|
|
// Chop off the "-journal" suffix.
|
|
NS_NAMED_LITERAL_CSTRING(kJournalSuffix, "-journal");
|
|
MOZ_ASSERT(StringEndsWith(journalPath, kJournalSuffix));
|
|
|
|
journalPath.Rebind(journalStart,
|
|
journalPath.Length() - kJournalSuffix.Length());
|
|
MOZ_ASSERT(!journalPath.IsEmpty());
|
|
|
|
// Make sure that the database name is a substring of the journal name.
|
|
MOZ_ASSERT(journalPath == dbPath);
|
|
}
|
|
#endif
|
|
|
|
// Now we're either at the end of the key/value URI pairs or we're at the
|
|
// end of the database path. Carefully walk backwards one character at a
|
|
// time to do this safely without running past the beginning of the database
|
|
// path.
|
|
const char *const dbPathStart = dbPath.BeginReading();
|
|
const char *dbPathCursor = dbPath.EndReading() - 1;
|
|
bool isDBPath = true;
|
|
|
|
while (true) {
|
|
MOZ_ASSERT(*dbPathCursor, "dbPathCursor should never see a null char!");
|
|
|
|
if (isDBPath) {
|
|
isDBPath = dbPathStart <= dbPathCursor &&
|
|
*dbPathCursor == *cursor &&
|
|
*cursor;
|
|
}
|
|
|
|
if (!isDBPath) {
|
|
// This isn't the database path so it must be a value. Scan past it and
|
|
// the key also.
|
|
for (size_t stringCount = 0; stringCount < 2; stringCount++) {
|
|
// Scan past the string to the preceding null character.
|
|
while (*cursor) {
|
|
cursor--;
|
|
}
|
|
|
|
// Back up one more char to the last char of preceding string.
|
|
cursor--;
|
|
}
|
|
|
|
// Reset and start again.
|
|
dbPathCursor = dbPath.EndReading() - 1;
|
|
isDBPath = true;
|
|
|
|
continue;
|
|
}
|
|
|
|
MOZ_ASSERT(isDBPath);
|
|
MOZ_ASSERT(*cursor);
|
|
|
|
if (dbPathStart == dbPathCursor) {
|
|
// Found the full database path, we're all done.
|
|
MOZ_ASSERT(nsDependentCString(cursor) == dbPath);
|
|
return cursor;
|
|
}
|
|
|
|
// Change the cursors and go through the loop again.
|
|
cursor--;
|
|
dbPathCursor--;
|
|
}
|
|
|
|
MOZ_CRASH("Should never get here!");
|
|
}
|
|
|
|
already_AddRefed<QuotaObject> GetQuotaObjectFromName(const char *zName,
|
|
bool deriveFromWal) {
|
|
// From Sqlite 3.31.0 the zName format changed to work consistently across
|
|
// database, wal and journal names.
|
|
// We must support both ways because this code will be uplifted to ensure
|
|
// that if system Sqlite is upgraded before us, we keep working properly.
|
|
// Once the Firefox minimum Sqlite version is 3.31.0, we can remove the else
|
|
// branch, DatabasePathFromWALPath, and the deriveFromWal argument.
|
|
const char* filename = zName;
|
|
if (deriveFromWal && sqlite3_libversion_number() < 3031000) {
|
|
filename = DatabasePathFromWALPath(zName);
|
|
}
|
|
MOZ_ASSERT(filename);
|
|
|
|
const char *persistenceType =
|
|
sqlite3_uri_parameter(filename, "persistenceType");
|
|
if (!persistenceType) {
|
|
return nullptr;
|
|
}
|
|
|
|
const char *group = sqlite3_uri_parameter(filename, "group");
|
|
if (!group) {
|
|
NS_WARNING("SQLite URI had 'persistenceType' but not 'group'?!");
|
|
return nullptr;
|
|
}
|
|
|
|
const char *origin = sqlite3_uri_parameter(filename, "origin");
|
|
if (!origin) {
|
|
NS_WARNING("SQLite URI had 'persistenceType' and 'group' but not "
|
|
"'origin'?!");
|
|
return nullptr;
|
|
}
|
|
|
|
QuotaManager *quotaManager = QuotaManager::Get();
|
|
MOZ_ASSERT(quotaManager);
|
|
|
|
return quotaManager->GetQuotaObject(
|
|
PersistenceTypeFromText(nsDependentCString(persistenceType)),
|
|
nsDependentCString(group),
|
|
nsDependentCString(origin),
|
|
NS_ConvertUTF8toUTF16(zName));
|
|
}
|
|
|
|
void
|
|
MaybeEstablishQuotaControl(const char *zName,
|
|
telemetry_file *pFile,
|
|
int flags)
|
|
{
|
|
MOZ_ASSERT(pFile);
|
|
MOZ_ASSERT(!pFile->quotaObject);
|
|
|
|
if (!(flags & (SQLITE_OPEN_URI | SQLITE_OPEN_WAL))) {
|
|
return;
|
|
}
|
|
|
|
pFile->quotaObject = GetQuotaObjectFromName(zName, flags & SQLITE_OPEN_WAL);
|
|
}
|
|
|
|
/*
|
|
** Close a telemetry_file.
|
|
*/
|
|
int
|
|
xClose(sqlite3_file *pFile)
|
|
{
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
int rc;
|
|
{ // Scope for IOThreadAutoTimer
|
|
IOThreadAutoTimer ioTimer(IOInterposeObserver::OpClose);
|
|
rc = p->pReal->pMethods->xClose(p->pReal);
|
|
}
|
|
if( rc==SQLITE_OK ){
|
|
delete p->base.pMethods;
|
|
p->base.pMethods = nullptr;
|
|
p->quotaObject = nullptr;
|
|
#ifdef DEBUG
|
|
p->fileChunkSize = 0;
|
|
#endif
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
** Read data from a telemetry_file.
|
|
*/
|
|
int
|
|
xRead(sqlite3_file *pFile, void *zBuf, int iAmt, sqlite_int64 iOfst)
|
|
{
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
IOThreadAutoTimer ioTimer(p->histograms->readMS, IOInterposeObserver::OpRead);
|
|
int rc;
|
|
rc = p->pReal->pMethods->xRead(p->pReal, zBuf, iAmt, iOfst);
|
|
// sqlite likes to read from empty files, this is normal, ignore it.
|
|
if (rc != SQLITE_IOERR_SHORT_READ)
|
|
Telemetry::Accumulate(p->histograms->readB, rc == SQLITE_OK ? iAmt : 0);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
** Return the current file-size of a telemetry_file.
|
|
*/
|
|
int
|
|
xFileSize(sqlite3_file *pFile, sqlite_int64 *pSize)
|
|
{
|
|
IOThreadAutoTimer ioTimer(IOInterposeObserver::OpStat);
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
int rc;
|
|
rc = p->pReal->pMethods->xFileSize(p->pReal, pSize);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
** Write data to a telemetry_file.
|
|
*/
|
|
int
|
|
xWrite(sqlite3_file *pFile, const void *zBuf, int iAmt, sqlite_int64 iOfst)
|
|
{
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
IOThreadAutoTimer ioTimer(p->histograms->writeMS, IOInterposeObserver::OpWrite);
|
|
int rc;
|
|
if (p->quotaObject) {
|
|
MOZ_ASSERT(INT64_MAX - iOfst >= iAmt);
|
|
if (!p->quotaObject->MaybeUpdateSize(iOfst + iAmt, /* aTruncate */ false)) {
|
|
return SQLITE_FULL;
|
|
}
|
|
}
|
|
rc = p->pReal->pMethods->xWrite(p->pReal, zBuf, iAmt, iOfst);
|
|
Telemetry::Accumulate(p->histograms->writeB, rc == SQLITE_OK ? iAmt : 0);
|
|
if (p->quotaObject && rc != SQLITE_OK) {
|
|
NS_WARNING("xWrite failed on a quota-controlled file, attempting to "
|
|
"update its current size...");
|
|
sqlite_int64 currentSize;
|
|
if (xFileSize(pFile, ¤tSize) == SQLITE_OK) {
|
|
p->quotaObject->MaybeUpdateSize(currentSize, /* aTruncate */ true);
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
** Truncate a telemetry_file.
|
|
*/
|
|
int
|
|
xTruncate(sqlite3_file *pFile, sqlite_int64 size)
|
|
{
|
|
IOThreadAutoTimer ioTimer(Telemetry::MOZ_SQLITE_TRUNCATE_MS);
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
int rc;
|
|
Telemetry::AutoTimer<Telemetry::MOZ_SQLITE_TRUNCATE_MS> timer;
|
|
if (p->quotaObject) {
|
|
if (p->fileChunkSize > 0) {
|
|
// Round up to the smallest multiple of the chunk size that will hold all
|
|
// the data.
|
|
size =
|
|
((size + p->fileChunkSize - 1) / p->fileChunkSize) * p->fileChunkSize;
|
|
}
|
|
if (!p->quotaObject->MaybeUpdateSize(size, /* aTruncate */ true)) {
|
|
return SQLITE_FULL;
|
|
}
|
|
}
|
|
rc = p->pReal->pMethods->xTruncate(p->pReal, size);
|
|
if (p->quotaObject) {
|
|
if (rc == SQLITE_OK) {
|
|
#ifdef DEBUG
|
|
// Make sure xTruncate set the size exactly as we calculated above.
|
|
sqlite_int64 newSize;
|
|
MOZ_ASSERT(xFileSize(pFile, &newSize) == SQLITE_OK);
|
|
MOZ_ASSERT(newSize == size);
|
|
#endif
|
|
} else {
|
|
NS_WARNING("xTruncate failed on a quota-controlled file, attempting to "
|
|
"update its current size...");
|
|
if (xFileSize(pFile, &size) == SQLITE_OK) {
|
|
p->quotaObject->MaybeUpdateSize(size, /* aTruncate */ true);
|
|
}
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
** Sync a telemetry_file.
|
|
*/
|
|
int
|
|
xSync(sqlite3_file *pFile, int flags)
|
|
{
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
IOThreadAutoTimer ioTimer(p->histograms->syncMS, IOInterposeObserver::OpFSync);
|
|
return p->pReal->pMethods->xSync(p->pReal, flags);
|
|
}
|
|
|
|
/*
|
|
** Lock a telemetry_file.
|
|
*/
|
|
int
|
|
xLock(sqlite3_file *pFile, int eLock)
|
|
{
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
int rc;
|
|
rc = p->pReal->pMethods->xLock(p->pReal, eLock);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
** Unlock a telemetry_file.
|
|
*/
|
|
int
|
|
xUnlock(sqlite3_file *pFile, int eLock)
|
|
{
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
int rc;
|
|
rc = p->pReal->pMethods->xUnlock(p->pReal, eLock);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
** Check if another file-handle holds a RESERVED lock on a telemetry_file.
|
|
*/
|
|
int
|
|
xCheckReservedLock(sqlite3_file *pFile, int *pResOut)
|
|
{
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
int rc = p->pReal->pMethods->xCheckReservedLock(p->pReal, pResOut);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
** File control method. For custom operations on a telemetry_file.
|
|
*/
|
|
int
|
|
xFileControl(sqlite3_file *pFile, int op, void *pArg)
|
|
{
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
int rc;
|
|
// Hook SQLITE_FCNTL_SIZE_HINT for quota-controlled files and do the necessary
|
|
// work before passing to the SQLite VFS.
|
|
if (op == SQLITE_FCNTL_SIZE_HINT && p->quotaObject) {
|
|
sqlite3_int64 hintSize = *static_cast<sqlite3_int64*>(pArg);
|
|
sqlite3_int64 currentSize;
|
|
rc = xFileSize(pFile, ¤tSize);
|
|
if (rc != SQLITE_OK) {
|
|
return rc;
|
|
}
|
|
if (hintSize > currentSize) {
|
|
rc = xTruncate(pFile, hintSize);
|
|
if (rc != SQLITE_OK) {
|
|
return rc;
|
|
}
|
|
}
|
|
}
|
|
rc = p->pReal->pMethods->xFileControl(p->pReal, op, pArg);
|
|
// Grab the file chunk size after the SQLite VFS has approved.
|
|
if (op == SQLITE_FCNTL_CHUNK_SIZE && rc == SQLITE_OK) {
|
|
p->fileChunkSize = *static_cast<int*>(pArg);
|
|
}
|
|
#ifdef DEBUG
|
|
if (op == SQLITE_FCNTL_SIZE_HINT && p->quotaObject && rc == SQLITE_OK) {
|
|
sqlite3_int64 hintSize = *static_cast<sqlite3_int64*>(pArg);
|
|
if (p->fileChunkSize > 0) {
|
|
hintSize =
|
|
((hintSize + p->fileChunkSize - 1) / p->fileChunkSize) *
|
|
p->fileChunkSize;
|
|
}
|
|
sqlite3_int64 currentSize;
|
|
MOZ_ASSERT(xFileSize(pFile, ¤tSize) == SQLITE_OK);
|
|
MOZ_ASSERT(currentSize >= hintSize);
|
|
}
|
|
#endif
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
** Return the sector-size in bytes for a telemetry_file.
|
|
*/
|
|
int
|
|
xSectorSize(sqlite3_file *pFile)
|
|
{
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
int rc;
|
|
rc = p->pReal->pMethods->xSectorSize(p->pReal);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
** Return the device characteristic flags supported by a telemetry_file.
|
|
*/
|
|
int
|
|
xDeviceCharacteristics(sqlite3_file *pFile)
|
|
{
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
int rc;
|
|
rc = p->pReal->pMethods->xDeviceCharacteristics(p->pReal);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
** Shared-memory operations.
|
|
*/
|
|
int
|
|
xShmLock(sqlite3_file *pFile, int ofst, int n, int flags)
|
|
{
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
return p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags);
|
|
}
|
|
|
|
int
|
|
xShmMap(sqlite3_file *pFile, int iRegion, int szRegion, int isWrite, void volatile **pp)
|
|
{
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
int rc;
|
|
rc = p->pReal->pMethods->xShmMap(p->pReal, iRegion, szRegion, isWrite, pp);
|
|
return rc;
|
|
}
|
|
|
|
void
|
|
xShmBarrier(sqlite3_file *pFile){
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
p->pReal->pMethods->xShmBarrier(p->pReal);
|
|
}
|
|
|
|
int
|
|
xShmUnmap(sqlite3_file *pFile, int delFlag){
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
int rc;
|
|
rc = p->pReal->pMethods->xShmUnmap(p->pReal, delFlag);
|
|
return rc;
|
|
}
|
|
|
|
int
|
|
xFetch(sqlite3_file *pFile, sqlite3_int64 iOff, int iAmt, void **pp)
|
|
{
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
MOZ_ASSERT(p->pReal->pMethods->iVersion >= 3);
|
|
return p->pReal->pMethods->xFetch(p->pReal, iOff, iAmt, pp);
|
|
}
|
|
|
|
int
|
|
xUnfetch(sqlite3_file *pFile, sqlite3_int64 iOff, void *pResOut)
|
|
{
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
MOZ_ASSERT(p->pReal->pMethods->iVersion >= 3);
|
|
return p->pReal->pMethods->xUnfetch(p->pReal, iOff, pResOut);
|
|
}
|
|
|
|
int
|
|
xOpen(sqlite3_vfs* vfs, const char *zName, sqlite3_file* pFile,
|
|
int flags, int *pOutFlags)
|
|
{
|
|
IOThreadAutoTimer ioTimer(Telemetry::MOZ_SQLITE_OPEN_MS,
|
|
IOInterposeObserver::OpCreateOrOpen);
|
|
Telemetry::AutoTimer<Telemetry::MOZ_SQLITE_OPEN_MS> timer;
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
int rc;
|
|
telemetry_file *p = (telemetry_file *)pFile;
|
|
Histograms *h = nullptr;
|
|
// check if the filename is one we are probing for
|
|
for(size_t i = 0;i < sizeof(gHistograms)/sizeof(gHistograms[0]);i++) {
|
|
h = &gHistograms[i];
|
|
// last probe is the fallback probe
|
|
if (!h->name)
|
|
break;
|
|
if (!zName)
|
|
continue;
|
|
const char *match = strstr(zName, h->name);
|
|
if (!match)
|
|
continue;
|
|
char c = match[strlen(h->name)];
|
|
// include -wal/-journal too
|
|
if (!c || c == '-')
|
|
break;
|
|
}
|
|
p->histograms = h;
|
|
|
|
MaybeEstablishQuotaControl(zName, p, flags);
|
|
|
|
rc = orig_vfs->xOpen(orig_vfs, zName, p->pReal, flags, pOutFlags);
|
|
if( rc != SQLITE_OK )
|
|
return rc;
|
|
if( p->pReal->pMethods ){
|
|
sqlite3_io_methods *pNew = new sqlite3_io_methods;
|
|
const sqlite3_io_methods *pSub = p->pReal->pMethods;
|
|
memset(pNew, 0, sizeof(*pNew));
|
|
// If the io_methods version is higher than the last known one, you should
|
|
// update this VFS adding appropriate IO methods for any methods added in
|
|
// the version change.
|
|
pNew->iVersion = pSub->iVersion;
|
|
MOZ_ASSERT(pNew->iVersion <= LAST_KNOWN_IOMETHODS_VERSION);
|
|
pNew->xClose = xClose;
|
|
pNew->xRead = xRead;
|
|
pNew->xWrite = xWrite;
|
|
pNew->xTruncate = xTruncate;
|
|
pNew->xSync = xSync;
|
|
pNew->xFileSize = xFileSize;
|
|
pNew->xLock = xLock;
|
|
pNew->xUnlock = xUnlock;
|
|
pNew->xCheckReservedLock = xCheckReservedLock;
|
|
pNew->xFileControl = xFileControl;
|
|
pNew->xSectorSize = xSectorSize;
|
|
pNew->xDeviceCharacteristics = xDeviceCharacteristics;
|
|
if (pNew->iVersion >= 2) {
|
|
// Methods added in version 2.
|
|
pNew->xShmMap = pSub->xShmMap ? xShmMap : 0;
|
|
pNew->xShmLock = pSub->xShmLock ? xShmLock : 0;
|
|
pNew->xShmBarrier = pSub->xShmBarrier ? xShmBarrier : 0;
|
|
pNew->xShmUnmap = pSub->xShmUnmap ? xShmUnmap : 0;
|
|
}
|
|
if (pNew->iVersion >= 3) {
|
|
// Methods added in version 3.
|
|
// SQLite 3.7.17 calls these methods without checking for nullptr first,
|
|
// so we always define them. Verify that we're not going to call
|
|
// nullptrs, though.
|
|
MOZ_ASSERT(pSub->xFetch);
|
|
pNew->xFetch = xFetch;
|
|
MOZ_ASSERT(pSub->xUnfetch);
|
|
pNew->xUnfetch = xUnfetch;
|
|
}
|
|
pFile->pMethods = pNew;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
int
|
|
xDelete(sqlite3_vfs* vfs, const char *zName, int syncDir)
|
|
{
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
int rc;
|
|
RefPtr<QuotaObject> quotaObject;
|
|
|
|
if (StringEndsWith(nsDependentCString(zName), NS_LITERAL_CSTRING("-wal"))) {
|
|
quotaObject = GetQuotaObjectFromName(zName, true);
|
|
}
|
|
|
|
rc = orig_vfs->xDelete(orig_vfs, zName, syncDir);
|
|
if (rc == SQLITE_OK && quotaObject) {
|
|
MOZ_ALWAYS_TRUE(quotaObject->MaybeUpdateSize(0, /* aTruncate */ true));
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
int
|
|
xAccess(sqlite3_vfs *vfs, const char *zName, int flags, int *pResOut)
|
|
{
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
return orig_vfs->xAccess(orig_vfs, zName, flags, pResOut);
|
|
}
|
|
|
|
int
|
|
xFullPathname(sqlite3_vfs *vfs, const char *zName, int nOut, char *zOut)
|
|
{
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
return orig_vfs->xFullPathname(orig_vfs, zName, nOut, zOut);
|
|
}
|
|
|
|
void*
|
|
xDlOpen(sqlite3_vfs *vfs, const char *zFilename)
|
|
{
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
return orig_vfs->xDlOpen(orig_vfs, zFilename);
|
|
}
|
|
|
|
void
|
|
xDlError(sqlite3_vfs *vfs, int nByte, char *zErrMsg)
|
|
{
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
orig_vfs->xDlError(orig_vfs, nByte, zErrMsg);
|
|
}
|
|
|
|
void
|
|
(*xDlSym(sqlite3_vfs *vfs, void *pHdle, const char *zSym))(void){
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
return orig_vfs->xDlSym(orig_vfs, pHdle, zSym);
|
|
}
|
|
|
|
void
|
|
xDlClose(sqlite3_vfs *vfs, void *pHandle)
|
|
{
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
orig_vfs->xDlClose(orig_vfs, pHandle);
|
|
}
|
|
|
|
int
|
|
xRandomness(sqlite3_vfs *vfs, int nByte, char *zOut)
|
|
{
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
return orig_vfs->xRandomness(orig_vfs, nByte, zOut);
|
|
}
|
|
|
|
int
|
|
xSleep(sqlite3_vfs *vfs, int microseconds)
|
|
{
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
return orig_vfs->xSleep(orig_vfs, microseconds);
|
|
}
|
|
|
|
int
|
|
xCurrentTime(sqlite3_vfs *vfs, double *prNow)
|
|
{
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
return orig_vfs->xCurrentTime(orig_vfs, prNow);
|
|
}
|
|
|
|
int
|
|
xGetLastError(sqlite3_vfs *vfs, int nBuf, char *zBuf)
|
|
{
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
return orig_vfs->xGetLastError(orig_vfs, nBuf, zBuf);
|
|
}
|
|
|
|
int
|
|
xCurrentTimeInt64(sqlite3_vfs *vfs, sqlite3_int64 *piNow)
|
|
{
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
return orig_vfs->xCurrentTimeInt64(orig_vfs, piNow);
|
|
}
|
|
|
|
static
|
|
int
|
|
xSetSystemCall(sqlite3_vfs *vfs, const char *zName, sqlite3_syscall_ptr pFunc)
|
|
{
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
return orig_vfs->xSetSystemCall(orig_vfs, zName, pFunc);
|
|
}
|
|
|
|
static
|
|
sqlite3_syscall_ptr
|
|
xGetSystemCall(sqlite3_vfs *vfs, const char *zName)
|
|
{
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
return orig_vfs->xGetSystemCall(orig_vfs, zName);
|
|
}
|
|
|
|
static
|
|
const char *
|
|
xNextSystemCall(sqlite3_vfs *vfs, const char *zName)
|
|
{
|
|
sqlite3_vfs *orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
|
|
return orig_vfs->xNextSystemCall(orig_vfs, zName);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
namespace mozilla {
|
|
namespace storage {
|
|
|
|
sqlite3_vfs* ConstructTelemetryVFS()
|
|
{
|
|
#if defined(XP_WIN)
|
|
#define EXPECTED_VFS "win32"
|
|
#define EXPECTED_VFS_NFS "win32"
|
|
#else
|
|
#define EXPECTED_VFS "unix"
|
|
#define EXPECTED_VFS_NFS "unix-excl"
|
|
#endif
|
|
|
|
bool expected_vfs;
|
|
sqlite3_vfs *vfs;
|
|
if (Preferences::GetBool(PREF_NFS_FILESYSTEM)) {
|
|
vfs = sqlite3_vfs_find(EXPECTED_VFS_NFS);
|
|
expected_vfs = (vfs != nullptr);
|
|
}
|
|
else {
|
|
vfs = sqlite3_vfs_find(nullptr);
|
|
expected_vfs = vfs->zName && !strcmp(vfs->zName, EXPECTED_VFS);
|
|
}
|
|
if (!expected_vfs) {
|
|
return nullptr;
|
|
}
|
|
|
|
sqlite3_vfs *tvfs = new ::sqlite3_vfs;
|
|
memset(tvfs, 0, sizeof(::sqlite3_vfs));
|
|
// If the VFS version is higher than the last known one, you should update
|
|
// this VFS adding appropriate methods for any methods added in the version
|
|
// change.
|
|
tvfs->iVersion = vfs->iVersion;
|
|
MOZ_ASSERT(vfs->iVersion <= LAST_KNOWN_VFS_VERSION);
|
|
tvfs->szOsFile = sizeof(telemetry_file) - sizeof(sqlite3_file) + vfs->szOsFile;
|
|
tvfs->mxPathname = vfs->mxPathname;
|
|
tvfs->zName = "telemetry-vfs";
|
|
tvfs->pAppData = vfs;
|
|
tvfs->xOpen = xOpen;
|
|
tvfs->xDelete = xDelete;
|
|
tvfs->xAccess = xAccess;
|
|
tvfs->xFullPathname = xFullPathname;
|
|
tvfs->xDlOpen = xDlOpen;
|
|
tvfs->xDlError = xDlError;
|
|
tvfs->xDlSym = xDlSym;
|
|
tvfs->xDlClose = xDlClose;
|
|
tvfs->xRandomness = xRandomness;
|
|
tvfs->xSleep = xSleep;
|
|
tvfs->xCurrentTime = xCurrentTime;
|
|
tvfs->xGetLastError = xGetLastError;
|
|
if (tvfs->iVersion >= 2) {
|
|
// Methods added in version 2.
|
|
tvfs->xCurrentTimeInt64 = xCurrentTimeInt64;
|
|
}
|
|
if (tvfs->iVersion >= 3) {
|
|
// Methods added in version 3.
|
|
tvfs->xSetSystemCall = xSetSystemCall;
|
|
tvfs->xGetSystemCall = xGetSystemCall;
|
|
tvfs->xNextSystemCall = xNextSystemCall;
|
|
}
|
|
return tvfs;
|
|
}
|
|
|
|
} // namespace storage
|
|
} // namespace mozilla
|