test_underflowedCacheRescan.js

Enable keyboard shortcuts

/**

 * Any copyright is dedicated to the Public Domain.

 * http://creativecommons.org/publicdomain/zero/1.0/

*/

const { LocalStorageUtils } = ChromeUtils.importESModule(

  "resource://testing-common/dom/localstorage/test/modules/LocalStorageUtils.sys.mjs"

);

const badUsage = -5;

// This is -5, interpreted as an unsigned integer.

// Quota DB stores client usages as a string, not integer, unlike usage.

const badClientUsagesText = "L18446744073709551611";

const testDomain = "http://example.com";

// Flags from dom/quota/DirectoryMetadata.h

const kFlagAccessed = 1 << 1;

async function initStorage() {

  info("Initializing");

  let request = init();

  await requestFinished(request);

  info("Initializing temporary storage");

  request = initTemporaryStorage();

  await requestFinished(request);

/**

 * Setup storage for the tests: init, put value, and return current (real) usage

*/

async function setupStorage() {

  const principal = getPrincipal(testDomain);

  info("Clearing");

  let request = clear();

  await requestFinished(request);

  info("Writing known localStorage data");

    const storage = LocalStorageUtils.createStorage(principal);

    storage.setItem("foo", "bar");

    storage.close();

  info("Resetting to flush real usage to storage.sqlite and .metadata-v2");

  request = reset();

  await requestFinished(request);

  await initStorage();

  info("Getting the real cached usage");

  request = getCachedOriginUsage(principal);

  await requestFinished(request);

  const realUsage = request.result;

  Assert.greater(realUsage, 0, "Real usage should be positive");

  info("Resetting to safely edit storage.sqlite and .metadata-v2");

  request = reset();

  await requestFinished(request);

  return realUsage;

function corruptL1Cache(badUsage, badClientUsagesText) {

  const storageFile = getRelativeFile("storage.sqlite");

  const connection = Services.storage.openUnsharedDatabase(storageFile);

  try {

    connection.executeSimpleSQL(

      `UPDATE origin SET client_usages = '${badClientUsagesText}', ` +

        `usage = ${badUsage}`

);

  } finally {

    connection.close();

function corruptL2Cache(

  badUsage,

  badClientUsagesText,

  clearAccessedFlag = false

) {

  const metadataFile = getRelativeFile(

    "storage/default/http+++example.com/.metadata-v2"

);

  const fileStream = Cc[

    "@mozilla.org/network/file-input-stream;1"

  ].createInstance(Ci.nsIFileInputStream);

  fileStream.init(metadataFile, -1, -1, 0);

  const bufferedStream = Cc[

    "@mozilla.org/network/buffered-input-stream;1"

  ].createInstance(Ci.nsIBufferedInputStream);

  bufferedStream.init(fileStream, 512);

  const binaryIn = Cc["@mozilla.org/binaryinputstream;1"].createInstance(

    Ci.nsIBinaryInputStream

);

  binaryIn.setInputStream(bufferedStream);

  const lastAccessTime = binaryIn.read64();

  const persisted = binaryIn.readBoolean();

  const rawFlags = binaryIn.read32();

  const lastMaintenanceDate = binaryIn.read32();

  const suffix = binaryIn.readCString();

  const group = binaryIn.readCString();

  const storageOrigin = binaryIn.readCString();

  const isPrivate = binaryIn.readBoolean();

  const sentinel = binaryIn.read32();

  const quotaVersion = binaryIn.read32();

  // Don't read usage (read64) nor clientUsages (string): we don't need them

  // since we will overwrite them just below

  binaryIn.close();

  const outStream = Cc[

    "@mozilla.org/network/file-output-stream;1"

  ].createInstance(Ci.nsIFileOutputStream);

  outStream.init(metadataFile, -1, parseInt("0644", 8), 0);

  const binaryOut = Cc["@mozilla.org/binaryoutputstream;1"].createInstance(

    Ci.nsIBinaryOutputStream

);

  binaryOut.setOutputStream(outStream);

  binaryOut.write64(lastAccessTime);

  binaryOut.writeBoolean(persisted);

  binaryOut.write32(clearAccessedFlag ? rawFlags & ~kFlagAccessed : rawFlags);

  binaryOut.write32(lastMaintenanceDate);

  binaryOut.writeStringZ(suffix);

  binaryOut.writeStringZ(group);

  binaryOut.writeStringZ(storageOrigin);

  binaryOut.writeBoolean(isPrivate);

  binaryOut.write32(sentinel);

  binaryOut.write32(quotaVersion);

  binaryOut.write64(badUsage);

  binaryOut.writeStringZ(badClientUsagesText);

  binaryOut.close();

async function checkUsage(realUsage) {

  info("Verifying usage was corrected, not left underflowed");

  const principal = getPrincipal(testDomain);

  let request = getCachedOriginUsage(principal);

  await requestFinished(request);

  is(request.result, realUsage, "Usage should be restored to the real value");

  info("Resetting to verify the fix was persisted, not just recomputed");

  request = reset();

  await requestFinished(request);

    const storageFile = getRelativeFile("storage.sqlite");

    const connection = Services.storage.openUnsharedDatabase(storageFile);

    const stmt = connection.createStatement("SELECT usage FROM origin");

    try {

      ok(stmt.executeStep(), "Origin row should exist");

is(

        stmt.row.usage,

        realUsage,

        "Persisted usage should no longer be underflowed"

);

    } finally {

      stmt.finalize();

      connection.close();

/**

 * Corrupt L1 and L2 caches by putting underflow usage values, and make sure the

 * values are still OK afterwards because the bad values shall have been notcied

 * and a full rescan shall have been performed

*/

async function testL1L2Corruption() {

  const realUsage = await setupStorage();

  info("Injecting a underflowed usage value into L1 and L2");

  corruptL1Cache(badUsage, badClientUsagesText);

  corruptL2Cache(badUsage, badClientUsagesText);

  info("Initializing; this should detect the inconsistency and rescan");

  await initStorage();

  await checkUsage(realUsage);

/**

 * Same as testL1L2Corruption, but also clear the mAccessed flag, to be sure

 * we're testing the CheckIfUsageIsConsistent check which should trigger a full

 * rescan (a full rescan is always performed when mAccessed is true, regardless

 * of whether the the usage values are consistent or not).

*/

async function testL1L2CorruptionUnaccessedOrigin() {

  const realUsage = await setupStorage();

  info("Corrupting L1 and L2, clearing mAccessed flag in L2");

  corruptL1Cache(badUsage, badClientUsagesText);

  corruptL2Cache(badUsage, badClientUsagesText, /* clearAccessed */ true);

  info("Initializing; this should detect the inconsistency and rescan");

  await initStorage();

  await checkUsage(realUsage);

/**

 * Verifies that an origin whose L1 (storage.sqlite) and L2 (.metadata-v2)

 * caches both carry the same underflowed usage value (consistent with each

 * other, but wrong compared to the real on-disk data) gets rescanned and

 * corrected on the next initialization, instead of the bad value sticking

 * around forever.

*/

async function testSteps() {

  add_task(testL1L2Corruption);

  add_task(testL1L2CorruptionUnaccessedOrigin);