Revert "Issue #21 - Remove TelemertyVFS"

This:
- reverts commit 83ecae9ff7ee1469da1675435dbcf26d094aa1c6
- adds a failure check to Connection::GetQuotaObjects

This resolves #1768.

9 files changed, 1286 insertions, 1 deletions

diff --git a/storage/TelemetryVFS.cpp b/storage/TelemetryVFS.cpp
new file mode 100644
index 0000000000..eb102a0461
--- /dev/null
+++ b/storage/TelemetryVFS.cpp
@@ -0,0 +1,879 @@
+/* -*- 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 c155c64257..d1ad9229f1 100644
--- a/storage/moz.build
+++ b/storage/moz.build
@@ -70,6 +70,7 @@ UNIFIED_SOURCES += [
     'mozStorageStatementRow.cpp',
     'SQLCollations.cpp',
     'StorageBaseStatementInternal.cpp',
+    'TelemetryVFS.cpp',
     'VacuumManager.cpp',
 ]
 
diff --git a/storage/mozStorageConnection.cpp b/storage/mozStorageConnection.cpp
index 40a71c28b5..22842ed9e9 100644
--- a/storage/mozStorageConnection.cpp
+++ b/storage/mozStorageConnection.cpp
@@ -1991,6 +1991,10 @@ 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)
@@ -2011,6 +2015,11 @@ Connection::GetQuotaObjects(QuotaObject** aDatabaseQuotaObject,
     return convertResultCode(srv);
   }
 
+  RefPtr<QuotaObject> databaseQuotaObject = GetQuotaObjectForFile(file);
+  if (NS_WARN_IF(!databaseQuotaObject)) {
+    return NS_ERROR_FAILURE;
+  }  
+
   srv = ::sqlite3_file_control(mDBConn,
                                nullptr,
                                SQLITE_FCNTL_JOURNAL_POINTER,
@@ -2019,6 +2028,13 @@ Connection::GetQuotaObjects(QuotaObject** aDatabaseQuotaObject,
     return convertResultCode(srv);
   }
 
+  RefPtr<QuotaObject> journalQuotaObject = GetQuotaObjectForFile(file);
+  if (NS_WARN_IF(!journalQuotaObject)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  databaseQuotaObject.forget(aDatabaseQuotaObject);
+  journalQuotaObject.forget(aJournalQuotaObject);
   return NS_OK;
 }
 
diff --git a/storage/mozStorageService.cpp b/storage/mozStorageService.cpp
index 56c10a4d04..8c6f65232c 100644
--- a/storage/mozStorageService.cpp
+++ b/storage/mozStorageService.cpp
@@ -253,6 +253,7 @@ int32_t Service::sDefaultPageSize = PREF_TS_PAGESIZE_DEFAULT;
 
 Service::Service()
 : mMutex("Service::mMutex")
+, mSqliteVFS(nullptr)
 , mRegistrationMutex("Service::mRegistrationMutex")
 , mConnections()
 {
@@ -263,9 +264,13 @@ 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.
-  int rc = ::sqlite3_shutdown();
+  rc = ::sqlite3_shutdown();
   if (rc != SQLITE_OK)
     NS_WARNING("sqlite3 did not shutdown cleanly.");
 
@@ -273,6 +278,8 @@ Service::~Service()
   NS_ASSERTION(shutdownObserved, "Shutdown was not observed!");
 
   gService = nullptr;
+  delete mSqliteVFS;
+  mSqliteVFS = nullptr;
 }
 
 void
@@ -365,6 +372,8 @@ Service::shutdown()
   NS_IF_RELEASE(sXPConnect);
 }
 
+sqlite3_vfs *ConstructTelemetryVFS();
+
 #ifdef MOZ_STORAGE_MEMORY
 
 namespace {
@@ -472,6 +481,15 @@ 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 d3c1d74d8b..effd330b16 100644
--- a/storage/mozStorageService.h
+++ b/storage/mozStorageService.h
@@ -19,6 +19,7 @@
 
 class nsIMemoryReporter;
 class nsIXPConnect;
+struct sqlite3_vfs;
 
 namespace mozilla {
 namespace storage {
@@ -135,6 +136,8 @@ 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
new file mode 100644
index 0000000000..0822fe3e7e
--- /dev/null
+++ b/storage/test/unit/test_telemetry_vfs.js
@@ -0,0 +1,30 @@
+/* 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 f9075a595d..e93c7d5b98 100644
--- a/storage/test/unit/xpcshell.ini
+++ b/storage/test/unit/xpcshell.ini
@@ -41,5 +41,6 @@ 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"
diff --git a/toolkit/components/telemetry/Histograms.json b/toolkit/components/telemetry/Histograms.json
index deae9e8de8..d4974cf5aa 100644
--- a/toolkit/components/telemetry/Histograms.json
+++ b/toolkit/components/telemetry/Histograms.json
@@ -3696,6 +3696,265 @@
     "n_values": 30,
     "description": "Flash object instances count on page"
   },
+  "MOZ_SQLITE_OPEN_MS": {
+    "expires_in_version": "default",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite open() (ms)"
+  },
+  "MOZ_SQLITE_OPEN_MAIN_THREAD_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite open() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_TRUNCATE_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite truncate() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_TRUNCATE_MAIN_THREAD_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite truncate() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_OTHER_READ_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite read() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_OTHER_READ_MAIN_THREAD_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite read() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_PLACES_READ_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite read() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_PLACES_READ_MAIN_THREAD_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite read() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_COOKIES_OPEN_READAHEAD_MS": {
+    "expires_in_version": "never",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on cookie DB open with readahead (ms)"
+  },
+  "MOZ_SQLITE_COOKIES_READ_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite read() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_COOKIES_READ_MAIN_THREAD_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite read() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_WEBAPPS_READ_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite read() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_WEBAPPS_READ_MAIN_THREAD_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite read() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_OTHER_WRITE_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite write() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_OTHER_WRITE_MAIN_THREAD_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite write() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_PLACES_WRITE_MS": {
+    "expires_in_version": "default",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite write() (ms)"
+  },
+  "MOZ_SQLITE_PLACES_WRITE_MAIN_THREAD_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite write() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_COOKIES_WRITE_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite write() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_COOKIES_WRITE_MAIN_THREAD_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite write() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_WEBAPPS_WRITE_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite write() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_WEBAPPS_WRITE_MAIN_THREAD_MS": {
+    "expires_in_version": "40",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite write() (ms) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_OTHER_SYNC_MS": {
+    "expires_in_version": "never",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite fsync() (ms)"
+  },
+  "MOZ_SQLITE_OTHER_SYNC_MAIN_THREAD_MS": {
+    "expires_in_version": "never",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite fsync() (ms)"
+  },
+  "MOZ_SQLITE_PLACES_SYNC_MS": {
+    "expires_in_version": "never",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite fsync() (ms)"
+  },
+  "MOZ_SQLITE_PLACES_SYNC_MAIN_THREAD_MS": {
+    "expires_in_version": "never",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite fsync() (ms)"
+  },
+  "MOZ_SQLITE_COOKIES_SYNC_MS": {
+    "expires_in_version": "never",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite fsync() (ms)"
+  },
+  "MOZ_SQLITE_COOKIES_SYNC_MAIN_THREAD_MS": {
+    "expires_in_version": "never",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite fsync() (ms)"
+  },
+  "MOZ_SQLITE_WEBAPPS_SYNC_MS": {
+    "expires_in_version": "never",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite fsync() (ms)"
+  },
+  "MOZ_SQLITE_WEBAPPS_SYNC_MAIN_THREAD_MS": {
+    "expires_in_version": "never",
+    "kind": "exponential",
+    "high": 3000,
+    "n_buckets": 10,
+    "description": "Time spent on SQLite fsync() (ms)"
+  },
+  "MOZ_SQLITE_OTHER_READ_B": {
+    "expires_in_version": "default",
+    "kind": "linear",
+    "high": 32768,
+    "n_buckets": 3,
+    "description": "SQLite read() (bytes)"
+  },
+  "MOZ_SQLITE_PLACES_READ_B": {
+    "expires_in_version": "40",
+    "kind": "linear",
+    "high": 32768,
+    "n_buckets": 3,
+    "description": "SQLite read() (bytes) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_COOKIES_READ_B": {
+    "expires_in_version": "40",
+    "kind": "linear",
+    "high": 32768,
+    "n_buckets": 3,
+    "description": "SQLite read() (bytes) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_WEBAPPS_READ_B": {
+    "expires_in_version": "40",
+    "kind": "linear",
+    "high": 32768,
+    "n_buckets": 3,
+    "description": "SQLite read() (bytes) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_PLACES_WRITE_B": {
+    "expires_in_version": "40",
+    "kind": "linear",
+    "high": 32768,
+    "n_buckets": 3,
+    "description": "SQLite write (bytes) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_COOKIES_WRITE_B": {
+    "expires_in_version": "40",
+    "kind": "linear",
+    "high": 32768,
+    "n_buckets": 3,
+    "description": "SQLite write (bytes) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_WEBAPPS_WRITE_B": {
+    "expires_in_version": "40",
+    "kind": "linear",
+    "high": 32768,
+    "n_buckets": 3,
+    "description": "SQLite write (bytes) *** No longer needed (bug 1156565). Delete histogram and accumulation code! ***"
+  },
+  "MOZ_SQLITE_OTHER_WRITE_B": {
+    "expires_in_version": "default",
+    "kind": "linear",
+    "high": 32768,
+    "n_buckets": 3,
+    "description": "SQLite write (bytes)"
+  },
   "MOZ_STORAGE_ASYNC_REQUESTS_MS": {
     "alert_emails": ["perf-telemetry-alerts@mozilla.com"],
     "expires_in_version": "40",
diff --git a/toolkit/components/telemetry/histogram-whitelists.json b/toolkit/components/telemetry/histogram-whitelists.json
index 0aa9061d74..722230ac9d 100644
--- a/toolkit/components/telemetry/histogram-whitelists.json
+++ b/toolkit/components/telemetry/histogram-whitelists.json
@@ -390,6 +390,43 @@
     "MEDIA_WMF_DECODE_ERROR",
     "MIXED_CONTENT_PAGE_LOAD",
     "MIXED_CONTENT_UNBLOCK_COUNTER",
+    "MOZ_SQLITE_COOKIES_OPEN_READAHEAD_MS",
+    "MOZ_SQLITE_COOKIES_READ_B",
+    "MOZ_SQLITE_COOKIES_READ_MAIN_THREAD_MS",
+    "MOZ_SQLITE_COOKIES_READ_MS",
+    "MOZ_SQLITE_COOKIES_SYNC_MAIN_THREAD_MS",
+    "MOZ_SQLITE_COOKIES_SYNC_MS",
+    "MOZ_SQLITE_COOKIES_WRITE_B",
+    "MOZ_SQLITE_COOKIES_WRITE_MAIN_THREAD_MS",
+    "MOZ_SQLITE_COOKIES_WRITE_MS",
+    "MOZ_SQLITE_OPEN_MAIN_THREAD_MS",
+    "MOZ_SQLITE_OPEN_MS",
+    "MOZ_SQLITE_OTHER_READ_B",
+    "MOZ_SQLITE_OTHER_READ_MAIN_THREAD_MS",
+    "MOZ_SQLITE_OTHER_READ_MS",
+    "MOZ_SQLITE_OTHER_SYNC_MAIN_THREAD_MS",
+    "MOZ_SQLITE_OTHER_SYNC_MS",
+    "MOZ_SQLITE_OTHER_WRITE_B",
+    "MOZ_SQLITE_OTHER_WRITE_MAIN_THREAD_MS",
+    "MOZ_SQLITE_OTHER_WRITE_MS",
+    "MOZ_SQLITE_PLACES_READ_B",
+    "MOZ_SQLITE_PLACES_READ_MAIN_THREAD_MS",
+    "MOZ_SQLITE_PLACES_READ_MS",
+    "MOZ_SQLITE_PLACES_SYNC_MAIN_THREAD_MS",
+    "MOZ_SQLITE_PLACES_SYNC_MS",
+    "MOZ_SQLITE_PLACES_WRITE_B",
+    "MOZ_SQLITE_PLACES_WRITE_MAIN_THREAD_MS",
+    "MOZ_SQLITE_PLACES_WRITE_MS",
+    "MOZ_SQLITE_TRUNCATE_MAIN_THREAD_MS",
+    "MOZ_SQLITE_TRUNCATE_MS",
+    "MOZ_SQLITE_WEBAPPS_READ_B",
+    "MOZ_SQLITE_WEBAPPS_READ_MAIN_THREAD_MS",
+    "MOZ_SQLITE_WEBAPPS_READ_MS",
+    "MOZ_SQLITE_WEBAPPS_SYNC_MAIN_THREAD_MS",
+    "MOZ_SQLITE_WEBAPPS_SYNC_MS",
+    "MOZ_SQLITE_WEBAPPS_WRITE_B",
+    "MOZ_SQLITE_WEBAPPS_WRITE_MAIN_THREAD_MS",
+    "MOZ_SQLITE_WEBAPPS_WRITE_MS",
     "NETWORK_CACHE_METADATA_FIRST_READ_SIZE",
     "NETWORK_CACHE_METADATA_FIRST_READ_TIME_MS",
     "NETWORK_CACHE_METADATA_SECOND_READ_TIME_MS",
@@ -1191,6 +1228,43 @@
     "MIXED_CONTENT_HSTS",
     "MIXED_CONTENT_PAGE_LOAD",
     "MIXED_CONTENT_UNBLOCK_COUNTER",
+    "MOZ_SQLITE_COOKIES_OPEN_READAHEAD_MS",
+    "MOZ_SQLITE_COOKIES_READ_B",
+    "MOZ_SQLITE_COOKIES_READ_MAIN_THREAD_MS",
+    "MOZ_SQLITE_COOKIES_READ_MS",
+    "MOZ_SQLITE_COOKIES_SYNC_MAIN_THREAD_MS",
+    "MOZ_SQLITE_COOKIES_SYNC_MS",
+    "MOZ_SQLITE_COOKIES_WRITE_B",
+    "MOZ_SQLITE_COOKIES_WRITE_MAIN_THREAD_MS",
+    "MOZ_SQLITE_COOKIES_WRITE_MS",
+    "MOZ_SQLITE_OPEN_MAIN_THREAD_MS",
+    "MOZ_SQLITE_OPEN_MS",
+    "MOZ_SQLITE_OTHER_READ_B",
+    "MOZ_SQLITE_OTHER_READ_MAIN_THREAD_MS",
+    "MOZ_SQLITE_OTHER_READ_MS",
+    "MOZ_SQLITE_OTHER_SYNC_MAIN_THREAD_MS",
+    "MOZ_SQLITE_OTHER_SYNC_MS",
+    "MOZ_SQLITE_OTHER_WRITE_B",
+    "MOZ_SQLITE_OTHER_WRITE_MAIN_THREAD_MS",
+    "MOZ_SQLITE_OTHER_WRITE_MS",
+    "MOZ_SQLITE_PLACES_READ_B",
+    "MOZ_SQLITE_PLACES_READ_MAIN_THREAD_MS",
+    "MOZ_SQLITE_PLACES_READ_MS",
+    "MOZ_SQLITE_PLACES_SYNC_MAIN_THREAD_MS",
+    "MOZ_SQLITE_PLACES_SYNC_MS",
+    "MOZ_SQLITE_PLACES_WRITE_B",
+    "MOZ_SQLITE_PLACES_WRITE_MAIN_THREAD_MS",
+    "MOZ_SQLITE_PLACES_WRITE_MS",
+    "MOZ_SQLITE_TRUNCATE_MAIN_THREAD_MS",
+    "MOZ_SQLITE_TRUNCATE_MS",
+    "MOZ_SQLITE_WEBAPPS_READ_B",
+    "MOZ_SQLITE_WEBAPPS_READ_MAIN_THREAD_MS",
+    "MOZ_SQLITE_WEBAPPS_READ_MS",
+    "MOZ_SQLITE_WEBAPPS_SYNC_MAIN_THREAD_MS",
+    "MOZ_SQLITE_WEBAPPS_SYNC_MS",
+    "MOZ_SQLITE_WEBAPPS_WRITE_B",
+    "MOZ_SQLITE_WEBAPPS_WRITE_MAIN_THREAD_MS",
+    "MOZ_SQLITE_WEBAPPS_WRITE_MS",
     "MOZ_STORAGE_ASYNC_REQUESTS_MS",
     "MOZ_STORAGE_ASYNC_REQUESTS_SUCCESS",
     "NETWORK_CACHE_METADATA_FIRST_READ_SIZE",
@@ -1807,6 +1881,7 @@
     "WEAVE_CONFIGURED",
     "NEWTAB_PAGE_ENABLED",
     "GRADIENT_DURATION",
+    "MOZ_SQLITE_OPEN_MS",
     "SHOULD_TRANSLATION_UI_APPEAR",
     "NEWTAB_PAGE_LIFE_SPAN",
     "FX_TOTAL_TOP_VISITS",
@@ -1823,6 +1898,7 @@
     "FX_NEW_WINDOW_MS",
     "PDF_VIEWER_TIME_TO_VIEW_MS",
     "SSL_OCSP_MAY_FETCH",
+    "MOZ_SQLITE_OTHER_READ_B",
     "CHECK_JAVA_ENABLED",
     "TRANSLATION_OPPORTUNITIES",
     "FX_SESSION_RESTORE_CONTENT_COLLECT_DATA_LONGEST_OP_MS",
@@ -1848,9 +1924,11 @@
     "FX_SESSION_RESTORE_DOM_STORAGE_SIZE_ESTIMATE_CHARS",
     "DATA_STORAGE_ENTRIES",
     "TRANSLATED_PAGES_BY_LANGUAGE",
+    "MOZ_SQLITE_OTHER_WRITE_B",
     "LOCALDOMSTORAGE_SHUTDOWN_DATABASE_MS",
     "SSL_CERT_VERIFICATION_ERRORS",
     "FX_SESSION_RESTORE_NUMBER_OF_WINDOWS_RESTORED",
+    "MOZ_SQLITE_PLACES_WRITE_MS",
     "FX_THUMBNAILS_BG_CAPTURE_CANVAS_DRAW_TIME_MS",
     "FX_SESSION_RESTORE_STARTUP_INIT_SESSION_MS",
     "FX_SESSION_RESTORE_WRITE_FILE_MS",