Source code
Revision control
Copy as Markdown
Other Tools
/* 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
#ifndef CacheStorageService__h__
#define CacheStorageService__h__
#include "mozilla/LinkedList.h"
#include "nsICacheStorageService.h"
#include "nsIMemoryReporter.h"
#include "nsINamed.h"
#include "nsITimer.h"
#include "nsICacheTesting.h"
#include "nsClassHashtable.h"
#include "nsTHashMap.h"
#include "nsString.h"
#include "nsThreadUtils.h"
#include "nsProxyRelease.h"
#include "mozilla/Monitor.h"
#include "mozilla/Mutex.h"
#include "mozilla/AtomicBitfields.h"
#include "mozilla/Atomics.h"
#include "mozilla/TimeStamp.h"
#include "nsTArray.h"
class nsIURI;
class nsICacheEntryDoomCallback;
class nsICacheStorageVisitor;
class nsIRunnable;
class nsIThread;
class nsIEventTarget;
namespace mozilla {
class OriginAttributes;
namespace net {
class CacheStorageService;
class CacheStorage;
class CacheEntry;
class CacheEntryHandle;
class CacheMemoryConsumer {
private:
friend class CacheStorageService;
// clang-format off
MOZ_ATOMIC_BITFIELDS(mAtomicBitfields, 32, (
(uint32_t, ReportedMemoryConsumption, 30),
(uint32_t, Flags, 2)
))
// clang-format on
private:
CacheMemoryConsumer() = delete;
protected:
enum {
// No special treatment, reports always to the disk-entries pool.
NORMAL = 0,
// This consumer is belonging to a memory-only cache entry, used to decide
// which of the two disk and memory pools count this consumption at.
MEMORY_ONLY = 1 << 0,
// Prevent reports of this consumer at all, used for disk data chunks since
// we throw them away as soon as the entry is not used by any consumer and
// don't want to make them wipe the whole pool out during their short life.
DONT_REPORT = 1 << 1
};
explicit CacheMemoryConsumer(uint32_t aFlags);
~CacheMemoryConsumer() { DoMemoryReport(0); }
void DoMemoryReport(uint32_t aCurrentSize);
};
class CacheStorageService final : public nsICacheStorageService,
public nsIMemoryReporter,
public nsITimerCallback,
public nsICacheTesting,
public nsINamed {
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSICACHESTORAGESERVICE
NS_DECL_NSIMEMORYREPORTER
NS_DECL_NSITIMERCALLBACK
NS_DECL_NSICACHETESTING
NS_DECL_NSINAMED
CacheStorageService();
void Shutdown();
void DropPrivateBrowsingEntries();
static CacheStorageService* Self() { return sSelf; }
static nsISupports* SelfISupports() {
return static_cast<nsICacheStorageService*>(Self());
}
nsresult Dispatch(nsIRunnable* aEvent);
static bool IsRunning() { return sSelf && !sSelf->mShutdown; }
static bool IsOnManagementThread();
already_AddRefed<nsIEventTarget> Thread() const;
mozilla::Mutex& Lock() { return mLock; }
// Tracks entries that may be forced valid in a pruned hashtable.
struct ForcedValidData {
// The timestamp is computed when the entry gets inserted into the map.
// It should never be null for an entry in the map.
TimeStamp validUntil;
// viewed gets set to true by a call to MarkForcedValidEntryUse()
bool viewed = false;
};
nsTHashMap<nsCStringHashKey, ForcedValidData> mForcedValidEntries;
void ForcedValidEntriesPrune(TimeStamp& now);
// Helper thread-safe interface to pass entry info, only difference from
// nsICacheStorageVisitor is that instead of nsIURI only the uri spec is
// passed.
class EntryInfoCallback {
public:
virtual void OnEntryInfo(const nsACString& aURISpec,
const nsACString& aIdEnhance, int64_t aDataSize,
int64_t aAltDataSize, uint32_t aFetchCount,
uint32_t aLastModifiedTime,
uint32_t aExpirationTime, bool aPinned,
nsILoadContextInfo* aInfo) = 0;
};
// Invokes OnEntryInfo for the given aEntry, synchronously.
static void GetCacheEntryInfo(CacheEntry* aEntry,
EntryInfoCallback* aCallback);
nsresult GetCacheIndexEntryAttrs(CacheStorage const* aStorage,
const nsACString& aURI,
const nsACString& aIdExtension,
bool* aHasAltData, uint32_t* aFileSizeKb);
static uint32_t CacheQueueSize(bool highPriority);
// Memory reporting
size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
MOZ_DEFINE_MALLOC_SIZE_OF(MallocSizeOf)
private:
virtual ~CacheStorageService();
void ShutdownBackground();
private:
// The following methods may only be called on the management
// thread.
friend class CacheEntry;
/**
* Registers the entry into the associated MemoryPool.
* Holds a strong reference until it is unregistered.
*/
void RegisterEntry(CacheEntry* aEntry);
/**
* Deregisters the entry from the associated MemoryPool.
*/
void UnregisterEntry(CacheEntry* aEntry);
/**
* Removes the entry from the related entry hash table, if still present.
*/
bool RemoveEntry(CacheEntry* aEntry, bool aOnlyUnreferenced = false);
/**
* Tells the storage service whether this entry is only to be stored in
* memory.
*/
void RecordMemoryOnlyEntry(CacheEntry* aEntry, bool aOnlyInMemory,
bool aOverwrite);
/**
* Sets a cache entry valid (overrides the default loading behavior by loading
* directly from cache) for the given number of seconds
* See nsICacheEntry.idl for more details
*/
void ForceEntryValidFor(nsACString const& aContextKey,
nsACString const& aEntryKey,
uint32_t aSecondsToTheFuture);
/**
* Remove the validity info
*/
void RemoveEntryForceValid(nsACString const& aContextKey,
nsACString const& aEntryKey);
/**
* Retrieves the status of the cache entry to see if it has been forced valid
* (so it will loaded directly from cache without further validation)
*/
bool IsForcedValidEntry(nsACString const& aContextKey,
nsACString const& aEntryKey);
// Marks the entry as used, so we may properly report when it gets evicted
// if the prefetched resource was used or not.
void MarkForcedValidEntryUse(nsACString const& aContextKey,
nsACString const& aEntryKey);
private:
friend class CacheIndex;
/**
* CacheIndex uses this to prevent a cache entry from being prememptively
* thrown away when forced valid
* See nsICacheEntry.idl for more details
*/
bool IsForcedValidEntry(nsACString const& aContextEntryKey);
private:
// These are helpers for telemetry monitoring of the memory pools.
void TelemetryPrune(TimeStamp& now);
void TelemetryRecordEntryCreation(CacheEntry const* entry);
void TelemetryRecordEntryRemoval(CacheEntry* entry);
private:
// Following methods are thread safe to call.
friend class CacheStorage;
/**
* Get, or create when not existing and demanded, an entry for the storage
* and uri+id extension.
*/
nsresult AddStorageEntry(CacheStorage const* aStorage, const nsACString& aURI,
const nsACString& aIdExtension, uint32_t aFlags,
CacheEntryHandle** aResult);
/**
* Check existance of an entry. This may throw NS_ERROR_NOT_AVAILABLE
* when the information cannot be obtained synchronously w/o blocking.
*/
nsresult CheckStorageEntry(CacheStorage const* aStorage,
const nsACString& aURI,
const nsACString& aIdExtension, bool* aResult);
/**
* Removes the entry from the related entry hash table, if still present
* and returns it.
*/
nsresult DoomStorageEntry(CacheStorage const* aStorage,
const nsACString& aURI,
const nsACString& aIdExtension,
nsICacheEntryDoomCallback* aCallback);
/**
* Removes and returns entry table for the storage.
*/
nsresult DoomStorageEntries(CacheStorage const* aStorage,
nsICacheEntryDoomCallback* aCallback);
/**
* Walk all entiries beloging to the storage.
*/
nsresult WalkStorageEntries(CacheStorage const* aStorage, bool aVisitEntries,
nsICacheStorageVisitor* aVisitor);
private:
friend class CacheFileIOManager;
/**
* CacheFileIOManager uses this method to notify CacheStorageService that
* an active entry was removed. This method is called even if the entry
* removal was originated by CacheStorageService.
*/
void CacheFileDoomed(nsILoadContextInfo* aLoadContextInfo,
const nsACString& aIdExtension,
const nsACString& aURISpec);
/**
* Tries to find an existing entry in the hashtables and synchronously call
* OnCacheEntryInfo of the aVisitor callback when found.
* @retuns
* true, when the entry has been found that also implies the callbacks has
* beem invoked
* false, when an entry has not been found
*/
bool GetCacheEntryInfo(nsILoadContextInfo* aLoadContextInfo,
const nsACString& aIdExtension,
const nsACString& aURISpec,
EntryInfoCallback* aCallback);
private:
friend class CacheMemoryConsumer;
/**
* When memory consumption of this entry radically changes, this method
* is called to reflect the size of allocated memory. This call may purge
* unspecified number of entries from memory (but not from disk).
*/
void OnMemoryConsumptionChange(CacheMemoryConsumer* aConsumer,
uint32_t aCurrentMemoryConsumption);
/**
* If not already pending, it schedules mPurgeTimer that fires after 1 second
* and dispatches PurgeOverMemoryLimit().
*/
void SchedulePurgeOverMemoryLimit();
/**
* Called on the management thread, removes all expired and then least used
* entries from the memory, first from the disk pool and then from the memory
* pool.
*/
void PurgeExpiredOrOverMemoryLimit();
private:
nsresult DoomStorageEntries(const nsACString& aContextKey,
nsILoadContextInfo* aContext, bool aDiskStorage,
bool aPin, nsICacheEntryDoomCallback* aCallback);
nsresult AddStorageEntry(const nsACString& aContextKey,
const nsACString& aURI,
const nsACString& aIdExtension, bool aWriteToDisk,
bool aSkipSizeCheck, bool aPin, uint32_t aFlags,
CacheEntryHandle** aResult);
nsresult ClearOriginInternal(
const nsAString& aOrigin,
const mozilla::OriginAttributes& aOriginAttributes, bool aAnonymous);
static CacheStorageService* sSelf;
mozilla::Mutex mLock MOZ_UNANNOTATED{"CacheStorageService.mLock"};
mozilla::Mutex mForcedValidEntriesLock{
"CacheStorageService.mForcedValidEntriesLock"};
Atomic<bool, Relaxed> mShutdown{false};
// Accessible only on the service thread
class MemoryPool {
public:
enum EType {
DISK,
MEMORY,
} mType;
explicit MemoryPool(EType aType);
~MemoryPool();
// We want to have constant O(1) for removal from this list.
LinkedList<RefPtr<CacheEntry>> mManagedEntries;
Atomic<uint32_t, Relaxed> mMemorySize{0};
bool OnMemoryConsumptionChange(uint32_t aSavedMemorySize,
uint32_t aCurrentMemoryConsumption);
/**
* Purges entries from memory based on the frecency ordered array.
*/
void PurgeExpiredOrOverMemoryLimit();
size_t PurgeExpired(size_t minprogress);
Result<size_t, nsresult> PurgeByFrecency(size_t minprogress);
size_t PurgeAll(uint32_t aWhat, size_t minprogress);
private:
uint32_t Limit() const;
MemoryPool() = delete;
};
MemoryPool mDiskPool{MemoryPool::DISK};
MemoryPool mMemoryPool{MemoryPool::MEMORY};
TimeStamp mLastPurgeTime;
MemoryPool& Pool(bool aUsingDisk) {
return aUsingDisk ? mDiskPool : mMemoryPool;
}
MemoryPool const& Pool(bool aUsingDisk) const {
return aUsingDisk ? mDiskPool : mMemoryPool;
}
nsCOMPtr<nsITimer> mPurgeTimer;
#ifdef MOZ_TSAN
// In OnMemoryConsumptionChange() we check whether the timer exists, but we
// a data race. This data race is harmless, so we use this atomic flag only in
// TSan build to suppress it.
Atomic<bool, Relaxed> mPurgeTimerActive{false};
#endif
class PurgeFromMemoryRunnable : public Runnable {
public:
PurgeFromMemoryRunnable(CacheStorageService* aService, uint32_t aWhat)
: Runnable("net::CacheStorageService::PurgeFromMemoryRunnable"),
mService(aService),
mWhat(aWhat) {}
private:
virtual ~PurgeFromMemoryRunnable() = default;
NS_IMETHOD Run() override;
RefPtr<CacheStorageService> mService;
uint32_t mWhat;
};
// Used just for telemetry purposes, accessed only on the management thread.
// Note: not included in the memory reporter, this is not expected to be huge
// and also would be complicated to report since reporting happens on the main
// thread but this table is manipulated on the management thread.
nsTHashMap<nsCStringHashKey, mozilla::TimeStamp> mPurgeTimeStamps;
// nsICacheTesting
class IOThreadSuspender : public Runnable {
public:
IOThreadSuspender()
: Runnable("net::CacheStorageService::IOThreadSuspender"),
mMon("IOThreadSuspender") {}
void Notify();
private:
virtual ~IOThreadSuspender() = default;
NS_IMETHOD Run() override;
Monitor mMon MOZ_UNANNOTATED;
bool mSignaled{false};
};
RefPtr<IOThreadSuspender> mActiveIOSuspender;
};
template <class T>
void ProxyRelease(const char* aName, nsCOMPtr<T>& object,
nsIEventTarget* target) {
NS_ProxyRelease(aName, target, object.forget());
}
template <class T>
void ProxyReleaseMainThread(const char* aName, nsCOMPtr<T>& object) {
ProxyRelease(aName, object, GetMainThreadSerialEventTarget());
}
} // namespace net
} // namespace mozilla
#define NS_CACHE_STORAGE_SERVICE_CID \
{ \
0xea70b098, 0x5014, 0x4e21, { \
0xae, 0xe1, 0x75, 0xe6, 0xb2, 0xc4, 0xb8, 0xe0 \
} \
}
#define NS_CACHE_STORAGE_SERVICE_CONTRACTID \
"@mozilla.org/netwerk/cache-storage-service;1"
#define NS_CACHE_STORAGE_SERVICE_CONTRACTID2 \
"@mozilla.org/network/cache-storage-service;1"
#endif