Issue #21 - Remove TelemertyVFS

This reverts m-c Bug 668378 and completely removes Telemetry SQLite IO. As a bonus this fixes a potential crash in newer SQLite versions without the need for updating this useless telemetry shim.

7 files changed, 1 insertions, 943 deletions

diff --git a/storage/TelemetryVFS.cpp b/storage/TelemetryVFS.cpp
deleted file mode 100644
index eb102a046..000000000
--- a/storage/TelemetryVFS.cpp
+++ /dev/null
@@ -1,879 +0,0 @@
-/* -*- 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 aId,
-    IOInterposeObserver::Operation aOp = IOInterposeObserver::OpNone)
-    : start(TimeStamp::Now()),
-      id(aId),
-      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()
-  {
-    // 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.
-  }
-
-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>
-GetQuotaObjectFromNameAndParameters(const char *zName,
-                                    const char *zURIParameterKey)
-{
-  MOZ_ASSERT(zName);
-  MOZ_ASSERT(zURIParameterKey);
-
-  const char *persistenceType =
-    sqlite3_uri_parameter(zURIParameterKey, "persistenceType");
-  if (!persistenceType) {
-    return nullptr;
-  }
-
-  const char *group = sqlite3_uri_parameter(zURIParameterKey, "group");
-  if (!group) {
-    NS_WARNING("SQLite URI had 'persistenceType' but not 'group'?!");
-    return nullptr;
-  }
-
-  const char *origin = sqlite3_uri_parameter(zURIParameterKey, "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;
-  }
-
-  MOZ_ASSERT(zName);
-
-  const char *zURIParameterKey = (flags & SQLITE_OPEN_WAL) ?
-                                 DatabasePathFromWALPath(zName) :
-                                 zName;
-
-  MOZ_ASSERT(zURIParameterKey);
-
-  pFile->quotaObject =
-    GetQuotaObjectFromNameAndParameters(zName, zURIParameterKey);
-}
-
-/*
-** 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.
-  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);
-  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, &currentSize) == 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;
-  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, &currentSize);
-    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, &currentSize) == 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);
-  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"))) {
-    const char *zURIParameterKey = DatabasePathFromWALPath(zName);
-    MOZ_ASSERT(zURIParameterKey);
-
-    quotaObject = GetQuotaObjectFromNameAndParameters(zName, zURIParameterKey);
-  }
-
-  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;
-}
-
-already_AddRefed<QuotaObject>
-GetQuotaObjectForFile(sqlite3_file *pFile)
-{
-  MOZ_ASSERT(pFile);
-
-  telemetry_file *p = (telemetry_file *)pFile;
-  RefPtr<QuotaObject> result = p->quotaObject;
-  return result.forget();
-}
-
-} // namespace storage
-} // namespace mozilla
diff --git a/storage/moz.build b/storage/moz.build
index 2d30a85ec..f0e754bdc 100644
--- a/storage/moz.build
+++ b/storage/moz.build
@@ -71,7 +71,6 @@ UNIFIED_SOURCES += [
     'mozStorageStatementRow.cpp',
     'SQLCollations.cpp',
     'StorageBaseStatementInternal.cpp',
-    'TelemetryVFS.cpp',
     'VacuumManager.cpp',
 ]
 
diff --git a/storage/mozStorageConnection.cpp b/storage/mozStorageConnection.cpp
index e6c357185..40a71c28b 100644
--- a/storage/mozStorageConnection.cpp
+++ b/storage/mozStorageConnection.cpp
@@ -1991,10 +1991,6 @@ Connection::EnableModule(const nsACString& aModuleName)
   return NS_ERROR_FAILURE;
 }
 
-// Implemented in TelemetryVFS.cpp
-already_AddRefed<QuotaObject>
-GetQuotaObjectForFile(sqlite3_file *pFile);
-
 NS_IMETHODIMP
 Connection::GetQuotaObjects(QuotaObject** aDatabaseQuotaObject,
                             QuotaObject** aJournalQuotaObject)
@@ -2015,8 +2011,6 @@ Connection::GetQuotaObjects(QuotaObject** aDatabaseQuotaObject,
     return convertResultCode(srv);
   }
 
-  RefPtr<QuotaObject> databaseQuotaObject = GetQuotaObjectForFile(file);
-
   srv = ::sqlite3_file_control(mDBConn,
                                nullptr,
                                SQLITE_FCNTL_JOURNAL_POINTER,
@@ -2025,10 +2019,6 @@ Connection::GetQuotaObjects(QuotaObject** aDatabaseQuotaObject,
     return convertResultCode(srv);
   }
 
-  RefPtr<QuotaObject> journalQuotaObject = GetQuotaObjectForFile(file);
-
-  databaseQuotaObject.forget(aDatabaseQuotaObject);
-  journalQuotaObject.forget(aJournalQuotaObject);
   return NS_OK;
 }
 
diff --git a/storage/mozStorageService.cpp b/storage/mozStorageService.cpp
index 8c6f65232..56c10a4d0 100644
--- a/storage/mozStorageService.cpp
+++ b/storage/mozStorageService.cpp
@@ -253,7 +253,6 @@ int32_t Service::sDefaultPageSize = PREF_TS_PAGESIZE_DEFAULT;
 
 Service::Service()
 : mMutex("Service::mMutex")
-, mSqliteVFS(nullptr)
 , mRegistrationMutex("Service::mRegistrationMutex")
 , mConnections()
 {
@@ -264,13 +263,9 @@ Service::~Service()
   mozilla::UnregisterWeakMemoryReporter(this);
   mozilla::UnregisterStorageSQLiteDistinguishedAmount();
 
-  int rc = sqlite3_vfs_unregister(mSqliteVFS);
-  if (rc != SQLITE_OK)
-    NS_WARNING("Failed to unregister sqlite vfs wrapper.");
-
   // Shutdown the sqlite3 API.  Warn if shutdown did not turn out okay, but
   // there is nothing actionable we can do in that case.
-  rc = ::sqlite3_shutdown();
+  int rc = ::sqlite3_shutdown();
   if (rc != SQLITE_OK)
     NS_WARNING("sqlite3 did not shutdown cleanly.");
 
@@ -278,8 +273,6 @@ Service::~Service()
   NS_ASSERTION(shutdownObserved, "Shutdown was not observed!");
 
   gService = nullptr;
-  delete mSqliteVFS;
-  mSqliteVFS = nullptr;
 }
 
 void
@@ -372,8 +365,6 @@ Service::shutdown()
   NS_IF_RELEASE(sXPConnect);
 }
 
-sqlite3_vfs *ConstructTelemetryVFS();
-
 #ifdef MOZ_STORAGE_MEMORY
 
 namespace {
@@ -481,15 +472,6 @@ Service::initialize()
   if (rc != SQLITE_OK)
     return convertResultCode(rc);
 
-  mSqliteVFS = ConstructTelemetryVFS();
-  if (mSqliteVFS) {
-    rc = sqlite3_vfs_register(mSqliteVFS, 1);
-    if (rc != SQLITE_OK)
-      return convertResultCode(rc);
-  } else {
-    NS_WARNING("Failed to register telemetry VFS");
-  }
-
   // Register for xpcom-shutdown so we can cleanup after ourselves.  The
   // observer service can only be used on the main thread.
   nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
diff --git a/storage/mozStorageService.h b/storage/mozStorageService.h
index effd330b1..d3c1d74d8 100644
--- a/storage/mozStorageService.h
+++ b/storage/mozStorageService.h
@@ -19,7 +19,6 @@
 
 class nsIMemoryReporter;
 class nsIXPConnect;
-struct sqlite3_vfs;
 
 namespace mozilla {
 namespace storage {
@@ -136,8 +135,6 @@ private:
    * synchronizing access to mLocaleCollation.
    */
   Mutex mMutex;
-  
-  sqlite3_vfs *mSqliteVFS;
 
   /**
    * Protects mConnections.
diff --git a/storage/test/unit/test_telemetry_vfs.js b/storage/test/unit/test_telemetry_vfs.js
deleted file mode 100644
index 0822fe3e7..000000000
--- a/storage/test/unit/test_telemetry_vfs.js
+++ /dev/null
@@ -1,30 +0,0 @@
-/* Any copyright is dedicated to the Public Domain.
- * http://creativecommons.org/publicdomain/zero/1.0/
- */
-
-// Make sure that there are telemetry entries created by sqlite io
-
-function run_sql(d, sql) {
-  var stmt = d.createStatement(sql);
-  stmt.execute();
-  stmt.finalize();
-}
-
-function new_file(name)
-{
-  var file = dirSvc.get("ProfD", Ci.nsIFile);
-  file.append(name);
-  return file;
-}
-function run_test()
-{
-  const Telemetry = Cc["@mozilla.org/base/telemetry;1"].getService(Ci.nsITelemetry);
-  let read_hgram = Telemetry.getHistogramById("MOZ_SQLITE_OTHER_READ_B");
-  let old_sum = read_hgram.snapshot().sum;
-  const file = new_file("telemetry.sqlite");
-  var d = getDatabase(file);
-  run_sql(d, "CREATE TABLE bloat(data varchar)");
-  run_sql(d, "DROP TABLE bloat");
-  do_check_true(read_hgram.snapshot().sum > old_sum);
-}
-
diff --git a/storage/test/unit/xpcshell.ini b/storage/test/unit/xpcshell.ini
index e93c7d5b9..f9075a595 100644
--- a/storage/test/unit/xpcshell.ini
+++ b/storage/test/unit/xpcshell.ini
@@ -41,6 +41,5 @@ fail-if = os == "android"
 [test_storage_value_array.js]
 [test_unicode.js]
 [test_vacuum.js]
-[test_telemetry_vfs.js]
 # Bug 676981: test fails consistently on Android
 # fail-if = os == "android"