diff options
Diffstat (limited to 'netwerk/cache/nsDiskCacheMap.cpp')
| -rw-r--r-- | netwerk/cache/nsDiskCacheMap.cpp | 1430 |
1 files changed, 1430 insertions, 0 deletions
diff --git a/netwerk/cache/nsDiskCacheMap.cpp b/netwerk/cache/nsDiskCacheMap.cpp new file mode 100644 index 000000000..d7ce13a35 --- /dev/null +++ b/netwerk/cache/nsDiskCacheMap.cpp @@ -0,0 +1,1430 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* vim:set ts=4 sw=4 sts=4 cin et: */ +/* 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 "nsCache.h" +#include "nsDiskCacheMap.h" +#include "nsDiskCacheBinding.h" +#include "nsDiskCacheEntry.h" +#include "nsDiskCacheDevice.h" +#include "nsCacheService.h" + +#include <string.h> +#include "nsPrintfCString.h" + +#include "nsISerializable.h" +#include "nsSerializationHelper.h" + +#include "mozilla/MemoryReporting.h" +#include "mozilla/Sprintf.h" +#include "mozilla/Telemetry.h" +#include <algorithm> + +using namespace mozilla; + +/****************************************************************************** + * nsDiskCacheMap + *****************************************************************************/ + +/** + * File operations + */ + +nsresult +nsDiskCacheMap::Open(nsIFile * cacheDirectory, + nsDiskCache::CorruptCacheInfo * corruptInfo) +{ + NS_ENSURE_ARG_POINTER(corruptInfo); + + // Assume we have an unexpected error until we find otherwise. + *corruptInfo = nsDiskCache::kUnexpectedError; + NS_ENSURE_ARG_POINTER(cacheDirectory); + if (mMapFD) return NS_ERROR_ALREADY_INITIALIZED; + + mCacheDirectory = cacheDirectory; // save a reference for ourselves + + // create nsIFile for _CACHE_MAP_ + nsresult rv; + nsCOMPtr<nsIFile> file; + rv = cacheDirectory->Clone(getter_AddRefs(file)); + rv = file->AppendNative(NS_LITERAL_CSTRING("_CACHE_MAP_")); + NS_ENSURE_SUCCESS(rv, rv); + + // open the file - restricted to user, the data could be confidential + rv = file->OpenNSPRFileDesc(PR_RDWR | PR_CREATE_FILE, 00600, &mMapFD); + if (NS_FAILED(rv)) { + *corruptInfo = nsDiskCache::kOpenCacheMapError; + NS_WARNING("Could not open cache map file"); + return NS_ERROR_FILE_CORRUPTED; + } + + bool cacheFilesExist = CacheFilesExist(); + rv = NS_ERROR_FILE_CORRUPTED; // presume the worst + uint32_t mapSize = PR_Available(mMapFD); + + if (NS_FAILED(InitCacheClean(cacheDirectory, + corruptInfo))) { + // corruptInfo is set in the call to InitCacheClean + goto error_exit; + } + + // check size of map file + if (mapSize == 0) { // creating a new _CACHE_MAP_ + + // block files shouldn't exist if we're creating the _CACHE_MAP_ + if (cacheFilesExist) { + *corruptInfo = nsDiskCache::kBlockFilesShouldNotExist; + goto error_exit; + } + + if (NS_FAILED(CreateCacheSubDirectories())) { + *corruptInfo = nsDiskCache::kCreateCacheSubdirectories; + goto error_exit; + } + + // create the file - initialize in memory + memset(&mHeader, 0, sizeof(nsDiskCacheHeader)); + mHeader.mVersion = nsDiskCache::kCurrentVersion; + mHeader.mRecordCount = kMinRecordCount; + mRecordArray = (nsDiskCacheRecord *) + PR_CALLOC(mHeader.mRecordCount * sizeof(nsDiskCacheRecord)); + if (!mRecordArray) { + *corruptInfo = nsDiskCache::kOutOfMemory; + rv = NS_ERROR_OUT_OF_MEMORY; + goto error_exit; + } + } else if (mapSize >= sizeof(nsDiskCacheHeader)) { // read existing _CACHE_MAP_ + + // if _CACHE_MAP_ exists, so should the block files + if (!cacheFilesExist) { + *corruptInfo = nsDiskCache::kBlockFilesShouldExist; + goto error_exit; + } + + CACHE_LOG_DEBUG(("CACHE: nsDiskCacheMap::Open [this=%p] reading map", this)); + + // read the header + uint32_t bytesRead = PR_Read(mMapFD, &mHeader, sizeof(nsDiskCacheHeader)); + if (sizeof(nsDiskCacheHeader) != bytesRead) { + *corruptInfo = nsDiskCache::kHeaderSizeNotRead; + goto error_exit; + } + mHeader.Unswap(); + + if (mHeader.mIsDirty) { + *corruptInfo = nsDiskCache::kHeaderIsDirty; + goto error_exit; + } + + if (mHeader.mVersion != nsDiskCache::kCurrentVersion) { + *corruptInfo = nsDiskCache::kVersionMismatch; + goto error_exit; + } + + uint32_t recordArraySize = + mHeader.mRecordCount * sizeof(nsDiskCacheRecord); + if (mapSize < recordArraySize + sizeof(nsDiskCacheHeader)) { + *corruptInfo = nsDiskCache::kRecordsIncomplete; + goto error_exit; + } + + // Get the space for the records + mRecordArray = (nsDiskCacheRecord *) PR_MALLOC(recordArraySize); + if (!mRecordArray) { + *corruptInfo = nsDiskCache::kOutOfMemory; + rv = NS_ERROR_OUT_OF_MEMORY; + goto error_exit; + } + + // Read the records + bytesRead = PR_Read(mMapFD, mRecordArray, recordArraySize); + if (bytesRead < recordArraySize) { + *corruptInfo = nsDiskCache::kNotEnoughToRead; + goto error_exit; + } + + // Unswap each record + int32_t total = 0; + for (int32_t i = 0; i < mHeader.mRecordCount; ++i) { + if (mRecordArray[i].HashNumber()) { +#if defined(IS_LITTLE_ENDIAN) + mRecordArray[i].Unswap(); +#endif + total ++; + } + } + + // verify entry count + if (total != mHeader.mEntryCount) { + *corruptInfo = nsDiskCache::kEntryCountIncorrect; + goto error_exit; + } + + } else { + *corruptInfo = nsDiskCache::kHeaderIncomplete; + goto error_exit; + } + + rv = OpenBlockFiles(corruptInfo); + if (NS_FAILED(rv)) { + // corruptInfo is set in the call to OpenBlockFiles + goto error_exit; + } + + // set dirty bit and flush header + mHeader.mIsDirty = true; + rv = FlushHeader(); + if (NS_FAILED(rv)) { + *corruptInfo = nsDiskCache::kFlushHeaderError; + goto error_exit; + } + + Telemetry::Accumulate(Telemetry::HTTP_DISK_CACHE_OVERHEAD, + (uint32_t)SizeOfExcludingThis(moz_malloc_size_of)); + + *corruptInfo = nsDiskCache::kNotCorrupt; + return NS_OK; + +error_exit: + (void) Close(false); + + return rv; +} + + +nsresult +nsDiskCacheMap::Close(bool flush) +{ + nsCacheService::AssertOwnsLock(); + nsresult rv = NS_OK; + + // Cancel any pending cache validation event, the FlushRecords call below + // will validate the cache. + if (mCleanCacheTimer) { + mCleanCacheTimer->Cancel(); + } + + // If cache map file and its block files are still open, close them + if (mMapFD) { + // close block files + rv = CloseBlockFiles(flush); + if (NS_SUCCEEDED(rv) && flush && mRecordArray) { + // write the map records + rv = FlushRecords(false); // don't bother swapping buckets back + if (NS_SUCCEEDED(rv)) { + // clear dirty bit + mHeader.mIsDirty = false; + rv = FlushHeader(); + } + } + if ((PR_Close(mMapFD) != PR_SUCCESS) && (NS_SUCCEEDED(rv))) + rv = NS_ERROR_UNEXPECTED; + + mMapFD = nullptr; + } + + if (mCleanFD) { + PR_Close(mCleanFD); + mCleanFD = nullptr; + } + + PR_FREEIF(mRecordArray); + PR_FREEIF(mBuffer); + mBufferSize = 0; + return rv; +} + + +nsresult +nsDiskCacheMap::Trim() +{ + nsresult rv, rv2 = NS_OK; + for (int i=0; i < kNumBlockFiles; ++i) { + rv = mBlockFile[i].Trim(); + if (NS_FAILED(rv)) rv2 = rv; // if one or more errors, report at least one + } + // Try to shrink the records array + rv = ShrinkRecords(); + if (NS_FAILED(rv)) rv2 = rv; // if one or more errors, report at least one + return rv2; +} + + +nsresult +nsDiskCacheMap::FlushHeader() +{ + if (!mMapFD) return NS_ERROR_NOT_AVAILABLE; + + // seek to beginning of cache map + int32_t filePos = PR_Seek(mMapFD, 0, PR_SEEK_SET); + if (filePos != 0) return NS_ERROR_UNEXPECTED; + + // write the header + mHeader.Swap(); + int32_t bytesWritten = PR_Write(mMapFD, &mHeader, sizeof(nsDiskCacheHeader)); + mHeader.Unswap(); + if (sizeof(nsDiskCacheHeader) != bytesWritten) { + return NS_ERROR_UNEXPECTED; + } + + PRStatus err = PR_Sync(mMapFD); + if (err != PR_SUCCESS) return NS_ERROR_UNEXPECTED; + + // If we have a clean header then revalidate the cache clean file + if (!mHeader.mIsDirty) { + RevalidateCache(); + } + + return NS_OK; +} + + +nsresult +nsDiskCacheMap::FlushRecords(bool unswap) +{ + if (!mMapFD) return NS_ERROR_NOT_AVAILABLE; + + // seek to beginning of buckets + int32_t filePos = PR_Seek(mMapFD, sizeof(nsDiskCacheHeader), PR_SEEK_SET); + if (filePos != sizeof(nsDiskCacheHeader)) + return NS_ERROR_UNEXPECTED; + +#if defined(IS_LITTLE_ENDIAN) + // Swap each record + for (int32_t i = 0; i < mHeader.mRecordCount; ++i) { + if (mRecordArray[i].HashNumber()) + mRecordArray[i].Swap(); + } +#endif + + int32_t recordArraySize = sizeof(nsDiskCacheRecord) * mHeader.mRecordCount; + + int32_t bytesWritten = PR_Write(mMapFD, mRecordArray, recordArraySize); + if (bytesWritten != recordArraySize) + return NS_ERROR_UNEXPECTED; + +#if defined(IS_LITTLE_ENDIAN) + if (unswap) { + // Unswap each record + for (int32_t i = 0; i < mHeader.mRecordCount; ++i) { + if (mRecordArray[i].HashNumber()) + mRecordArray[i].Unswap(); + } + } +#endif + + return NS_OK; +} + + +/** + * Record operations + */ + +uint32_t +nsDiskCacheMap::GetBucketRank(uint32_t bucketIndex, uint32_t targetRank) +{ + nsDiskCacheRecord * records = GetFirstRecordInBucket(bucketIndex); + uint32_t rank = 0; + + for (int i = mHeader.mBucketUsage[bucketIndex]-1; i >= 0; i--) { + if ((rank < records[i].EvictionRank()) && + ((targetRank == 0) || (records[i].EvictionRank() < targetRank))) + rank = records[i].EvictionRank(); + } + return rank; +} + +nsresult +nsDiskCacheMap::GrowRecords() +{ + if (mHeader.mRecordCount >= mMaxRecordCount) + return NS_OK; + CACHE_LOG_DEBUG(("CACHE: GrowRecords\n")); + + // Resize the record array + int32_t newCount = mHeader.mRecordCount << 1; + if (newCount > mMaxRecordCount) + newCount = mMaxRecordCount; + nsDiskCacheRecord *newArray = (nsDiskCacheRecord *) + PR_REALLOC(mRecordArray, newCount * sizeof(nsDiskCacheRecord)); + if (!newArray) + return NS_ERROR_OUT_OF_MEMORY; + + // Space out the buckets + uint32_t oldRecordsPerBucket = GetRecordsPerBucket(); + uint32_t newRecordsPerBucket = newCount / kBuckets; + // Work from back to space out each bucket to the new array + for (int bucketIndex = kBuckets - 1; bucketIndex >= 0; --bucketIndex) { + // Move bucket + nsDiskCacheRecord *newRecords = newArray + bucketIndex * newRecordsPerBucket; + const uint32_t count = mHeader.mBucketUsage[bucketIndex]; + memmove(newRecords, + newArray + bucketIndex * oldRecordsPerBucket, + count * sizeof(nsDiskCacheRecord)); + // clear unused records + memset(newRecords + count, 0, + (newRecordsPerBucket - count) * sizeof(nsDiskCacheRecord)); + } + + // Set as the new record array + mRecordArray = newArray; + mHeader.mRecordCount = newCount; + + InvalidateCache(); + + return NS_OK; +} + +nsresult +nsDiskCacheMap::ShrinkRecords() +{ + if (mHeader.mRecordCount <= kMinRecordCount) + return NS_OK; + CACHE_LOG_DEBUG(("CACHE: ShrinkRecords\n")); + + // Verify if we can shrink the record array: all buckets must be less than + // 1/2 filled + uint32_t maxUsage = 0, bucketIndex; + for (bucketIndex = 0; bucketIndex < kBuckets; ++bucketIndex) { + if (maxUsage < mHeader.mBucketUsage[bucketIndex]) + maxUsage = mHeader.mBucketUsage[bucketIndex]; + } + // Determine new bucket size, halve size until maxUsage + uint32_t oldRecordsPerBucket = GetRecordsPerBucket(); + uint32_t newRecordsPerBucket = oldRecordsPerBucket; + while (maxUsage < (newRecordsPerBucket >> 1)) + newRecordsPerBucket >>= 1; + if (newRecordsPerBucket < (kMinRecordCount / kBuckets)) + newRecordsPerBucket = (kMinRecordCount / kBuckets); + NS_ASSERTION(newRecordsPerBucket <= oldRecordsPerBucket, + "ShrinkRecords() can't grow records!"); + if (newRecordsPerBucket == oldRecordsPerBucket) + return NS_OK; + // Move the buckets close to each other + for (bucketIndex = 1; bucketIndex < kBuckets; ++bucketIndex) { + // Move bucket + memmove(mRecordArray + bucketIndex * newRecordsPerBucket, + mRecordArray + bucketIndex * oldRecordsPerBucket, + newRecordsPerBucket * sizeof(nsDiskCacheRecord)); + } + + // Shrink the record array memory block itself + uint32_t newCount = newRecordsPerBucket * kBuckets; + nsDiskCacheRecord* newArray = (nsDiskCacheRecord *) + PR_REALLOC(mRecordArray, newCount * sizeof(nsDiskCacheRecord)); + if (!newArray) + return NS_ERROR_OUT_OF_MEMORY; + + // Set as the new record array + mRecordArray = newArray; + mHeader.mRecordCount = newCount; + + InvalidateCache(); + + return NS_OK; +} + +nsresult +nsDiskCacheMap::AddRecord( nsDiskCacheRecord * mapRecord, + nsDiskCacheRecord * oldRecord) +{ + CACHE_LOG_DEBUG(("CACHE: AddRecord [%x]\n", mapRecord->HashNumber())); + + const uint32_t hashNumber = mapRecord->HashNumber(); + const uint32_t bucketIndex = GetBucketIndex(hashNumber); + const uint32_t count = mHeader.mBucketUsage[bucketIndex]; + + oldRecord->SetHashNumber(0); // signify no record + + if (count == GetRecordsPerBucket()) { + // Ignore failure to grow the record space, we will then reuse old records + GrowRecords(); + } + + nsDiskCacheRecord * records = GetFirstRecordInBucket(bucketIndex); + if (count < GetRecordsPerBucket()) { + // stick the new record at the end + records[count] = *mapRecord; + mHeader.mEntryCount++; + mHeader.mBucketUsage[bucketIndex]++; + if (mHeader.mEvictionRank[bucketIndex] < mapRecord->EvictionRank()) + mHeader.mEvictionRank[bucketIndex] = mapRecord->EvictionRank(); + InvalidateCache(); + } else { + // Find the record with the highest eviction rank + nsDiskCacheRecord * mostEvictable = &records[0]; + for (int i = count-1; i > 0; i--) { + if (records[i].EvictionRank() > mostEvictable->EvictionRank()) + mostEvictable = &records[i]; + } + *oldRecord = *mostEvictable; // i == GetRecordsPerBucket(), so + // evict the mostEvictable + *mostEvictable = *mapRecord; // replace it with the new record + // check if we need to update mostEvictable entry in header + if (mHeader.mEvictionRank[bucketIndex] < mapRecord->EvictionRank()) + mHeader.mEvictionRank[bucketIndex] = mapRecord->EvictionRank(); + if (oldRecord->EvictionRank() >= mHeader.mEvictionRank[bucketIndex]) + mHeader.mEvictionRank[bucketIndex] = GetBucketRank(bucketIndex, 0); + InvalidateCache(); + } + + NS_ASSERTION(mHeader.mEvictionRank[bucketIndex] == GetBucketRank(bucketIndex, 0), + "eviction rank out of sync"); + return NS_OK; +} + + +nsresult +nsDiskCacheMap::UpdateRecord( nsDiskCacheRecord * mapRecord) +{ + CACHE_LOG_DEBUG(("CACHE: UpdateRecord [%x]\n", mapRecord->HashNumber())); + + const uint32_t hashNumber = mapRecord->HashNumber(); + const uint32_t bucketIndex = GetBucketIndex(hashNumber); + nsDiskCacheRecord * records = GetFirstRecordInBucket(bucketIndex); + + for (int i = mHeader.mBucketUsage[bucketIndex]-1; i >= 0; i--) { + if (records[i].HashNumber() == hashNumber) { + const uint32_t oldRank = records[i].EvictionRank(); + + // stick the new record here + records[i] = *mapRecord; + + // update eviction rank in header if necessary + if (mHeader.mEvictionRank[bucketIndex] < mapRecord->EvictionRank()) + mHeader.mEvictionRank[bucketIndex] = mapRecord->EvictionRank(); + else if (mHeader.mEvictionRank[bucketIndex] == oldRank) + mHeader.mEvictionRank[bucketIndex] = GetBucketRank(bucketIndex, 0); + + InvalidateCache(); + +NS_ASSERTION(mHeader.mEvictionRank[bucketIndex] == GetBucketRank(bucketIndex, 0), + "eviction rank out of sync"); + return NS_OK; + } + } + NS_NOTREACHED("record not found"); + return NS_ERROR_UNEXPECTED; +} + + +nsresult +nsDiskCacheMap::FindRecord( uint32_t hashNumber, nsDiskCacheRecord * result) +{ + const uint32_t bucketIndex = GetBucketIndex(hashNumber); + nsDiskCacheRecord * records = GetFirstRecordInBucket(bucketIndex); + + for (int i = mHeader.mBucketUsage[bucketIndex]-1; i >= 0; i--) { + if (records[i].HashNumber() == hashNumber) { + *result = records[i]; // copy the record + NS_ASSERTION(result->ValidRecord(), "bad cache map record"); + return NS_OK; + } + } + return NS_ERROR_CACHE_KEY_NOT_FOUND; +} + + +nsresult +nsDiskCacheMap::DeleteRecord( nsDiskCacheRecord * mapRecord) +{ + CACHE_LOG_DEBUG(("CACHE: DeleteRecord [%x]\n", mapRecord->HashNumber())); + + const uint32_t hashNumber = mapRecord->HashNumber(); + const uint32_t bucketIndex = GetBucketIndex(hashNumber); + nsDiskCacheRecord * records = GetFirstRecordInBucket(bucketIndex); + uint32_t last = mHeader.mBucketUsage[bucketIndex]-1; + + for (int i = last; i >= 0; i--) { + if (records[i].HashNumber() == hashNumber) { + // found it, now delete it. + uint32_t evictionRank = records[i].EvictionRank(); + NS_ASSERTION(evictionRank == mapRecord->EvictionRank(), + "evictionRank out of sync"); + // if not the last record, shift last record into opening + records[i] = records[last]; + records[last].SetHashNumber(0); // clear last record + mHeader.mBucketUsage[bucketIndex] = last; + mHeader.mEntryCount--; + + // update eviction rank + uint32_t bucketIndex = GetBucketIndex(mapRecord->HashNumber()); + if (mHeader.mEvictionRank[bucketIndex] <= evictionRank) { + mHeader.mEvictionRank[bucketIndex] = GetBucketRank(bucketIndex, 0); + } + + InvalidateCache(); + + NS_ASSERTION(mHeader.mEvictionRank[bucketIndex] == + GetBucketRank(bucketIndex, 0), "eviction rank out of sync"); + return NS_OK; + } + } + return NS_ERROR_UNEXPECTED; +} + + +int32_t +nsDiskCacheMap::VisitEachRecord(uint32_t bucketIndex, + nsDiskCacheRecordVisitor * visitor, + uint32_t evictionRank) +{ + int32_t rv = kVisitNextRecord; + uint32_t count = mHeader.mBucketUsage[bucketIndex]; + nsDiskCacheRecord * records = GetFirstRecordInBucket(bucketIndex); + + // call visitor for each entry (matching any eviction rank) + for (int i = count-1; i >= 0; i--) { + if (evictionRank > records[i].EvictionRank()) continue; + + rv = visitor->VisitRecord(&records[i]); + if (rv == kStopVisitingRecords) + break; // Stop visiting records + + if (rv == kDeleteRecordAndContinue) { + --count; + records[i] = records[count]; + records[count].SetHashNumber(0); + InvalidateCache(); + } + } + + if (mHeader.mBucketUsage[bucketIndex] - count != 0) { + mHeader.mEntryCount -= mHeader.mBucketUsage[bucketIndex] - count; + mHeader.mBucketUsage[bucketIndex] = count; + // recalc eviction rank + mHeader.mEvictionRank[bucketIndex] = GetBucketRank(bucketIndex, 0); + } + NS_ASSERTION(mHeader.mEvictionRank[bucketIndex] == + GetBucketRank(bucketIndex, 0), "eviction rank out of sync"); + + return rv; +} + + +/** + * VisitRecords + * + * Visit every record in cache map in the most convenient order + */ +nsresult +nsDiskCacheMap::VisitRecords( nsDiskCacheRecordVisitor * visitor) +{ + for (int bucketIndex = 0; bucketIndex < kBuckets; ++bucketIndex) { + if (VisitEachRecord(bucketIndex, visitor, 0) == kStopVisitingRecords) + break; + } + return NS_OK; +} + + +/** + * EvictRecords + * + * Just like VisitRecords, but visits the records in order of their eviction rank + */ +nsresult +nsDiskCacheMap::EvictRecords( nsDiskCacheRecordVisitor * visitor) +{ + uint32_t tempRank[kBuckets]; + int bucketIndex = 0; + + // copy eviction rank array + for (bucketIndex = 0; bucketIndex < kBuckets; ++bucketIndex) + tempRank[bucketIndex] = mHeader.mEvictionRank[bucketIndex]; + + // Maximum number of iterations determined by number of records + // as a safety limiter for the loop. Use a copy of mHeader.mEntryCount since + // the value could decrease if some entry is evicted. + int32_t entryCount = mHeader.mEntryCount; + for (int n = 0; n < entryCount; ++n) { + + // find bucket with highest eviction rank + uint32_t rank = 0; + for (int i = 0; i < kBuckets; ++i) { + if (rank < tempRank[i]) { + rank = tempRank[i]; + bucketIndex = i; + } + } + + if (rank == 0) break; // we've examined all the records + + // visit records in bucket with eviction ranks >= target eviction rank + if (VisitEachRecord(bucketIndex, visitor, rank) == kStopVisitingRecords) + break; + + // find greatest rank less than 'rank' + tempRank[bucketIndex] = GetBucketRank(bucketIndex, rank); + } + return NS_OK; +} + + + +nsresult +nsDiskCacheMap::OpenBlockFiles(nsDiskCache::CorruptCacheInfo * corruptInfo) +{ + NS_ENSURE_ARG_POINTER(corruptInfo); + + // create nsIFile for block file + nsCOMPtr<nsIFile> blockFile; + nsresult rv = NS_OK; + *corruptInfo = nsDiskCache::kUnexpectedError; + + for (int i = 0; i < kNumBlockFiles; ++i) { + rv = GetBlockFileForIndex(i, getter_AddRefs(blockFile)); + if (NS_FAILED(rv)) { + *corruptInfo = nsDiskCache::kCouldNotGetBlockFileForIndex; + break; + } + + uint32_t blockSize = GetBlockSizeForIndex(i+1); // +1 to match file selectors 1,2,3 + uint32_t bitMapSize = GetBitMapSizeForIndex(i+1); + rv = mBlockFile[i].Open(blockFile, blockSize, bitMapSize, corruptInfo); + if (NS_FAILED(rv)) { + // corruptInfo was set inside the call to mBlockFile[i].Open + break; + } + } + // close all files in case of any error + if (NS_FAILED(rv)) + (void)CloseBlockFiles(false); // we already have an error to report + + return rv; +} + + +nsresult +nsDiskCacheMap::CloseBlockFiles(bool flush) +{ + nsresult rv, rv2 = NS_OK; + for (int i=0; i < kNumBlockFiles; ++i) { + rv = mBlockFile[i].Close(flush); + if (NS_FAILED(rv)) rv2 = rv; // if one or more errors, report at least one + } + return rv2; +} + + +bool +nsDiskCacheMap::CacheFilesExist() +{ + nsCOMPtr<nsIFile> blockFile; + nsresult rv; + + for (int i = 0; i < kNumBlockFiles; ++i) { + bool exists; + rv = GetBlockFileForIndex(i, getter_AddRefs(blockFile)); + if (NS_FAILED(rv)) return false; + + rv = blockFile->Exists(&exists); + if (NS_FAILED(rv) || !exists) return false; + } + + return true; +} + + +nsresult +nsDiskCacheMap::CreateCacheSubDirectories() +{ + if (!mCacheDirectory) + return NS_ERROR_UNEXPECTED; + + for (int32_t index = 0 ; index < 16 ; index++) { + nsCOMPtr<nsIFile> file; + nsresult rv = mCacheDirectory->Clone(getter_AddRefs(file)); + if (NS_FAILED(rv)) + return rv; + + rv = file->AppendNative(nsPrintfCString("%X", index)); + if (NS_FAILED(rv)) + return rv; + + rv = file->Create(nsIFile::DIRECTORY_TYPE, 0700); + if (NS_FAILED(rv)) + return rv; + } + + return NS_OK; +} + + +nsDiskCacheEntry * +nsDiskCacheMap::ReadDiskCacheEntry(nsDiskCacheRecord * record) +{ + CACHE_LOG_DEBUG(("CACHE: ReadDiskCacheEntry [%x]\n", record->HashNumber())); + + nsresult rv = NS_ERROR_UNEXPECTED; + nsDiskCacheEntry * diskEntry = nullptr; + uint32_t metaFile = record->MetaFile(); + int32_t bytesRead = 0; + + if (!record->MetaLocationInitialized()) return nullptr; + + if (metaFile == 0) { // entry/metadata stored in separate file + // open and read the file + nsCOMPtr<nsIFile> file; + rv = GetLocalFileForDiskCacheRecord(record, + nsDiskCache::kMetaData, + false, + getter_AddRefs(file)); + NS_ENSURE_SUCCESS(rv, nullptr); + + CACHE_LOG_DEBUG(("CACHE: nsDiskCacheMap::ReadDiskCacheEntry" + "[this=%p] reading disk cache entry", this)); + + PRFileDesc * fd = nullptr; + + // open the file - restricted to user, the data could be confidential + rv = file->OpenNSPRFileDesc(PR_RDONLY, 00600, &fd); + NS_ENSURE_SUCCESS(rv, nullptr); + + int32_t fileSize = PR_Available(fd); + if (fileSize < 0) { + // an error occurred. We could call PR_GetError(), but how would that help? + rv = NS_ERROR_UNEXPECTED; + } else { + rv = EnsureBuffer(fileSize); + if (NS_SUCCEEDED(rv)) { + bytesRead = PR_Read(fd, mBuffer, fileSize); + if (bytesRead < fileSize) { + rv = NS_ERROR_UNEXPECTED; + } + } + } + PR_Close(fd); + NS_ENSURE_SUCCESS(rv, nullptr); + + } else if (metaFile < (kNumBlockFiles + 1)) { + // entry/metadata stored in cache block file + + // allocate buffer + uint32_t blockCount = record->MetaBlockCount(); + bytesRead = blockCount * GetBlockSizeForIndex(metaFile); + + rv = EnsureBuffer(bytesRead); + NS_ENSURE_SUCCESS(rv, nullptr); + + // read diskEntry, note when the blocks are at the end of file, + // bytesRead may be less than blockSize*blockCount. + // But the bytesRead should at least agree with the real disk entry size. + rv = mBlockFile[metaFile - 1].ReadBlocks(mBuffer, + record->MetaStartBlock(), + blockCount, + &bytesRead); + NS_ENSURE_SUCCESS(rv, nullptr); + } + diskEntry = (nsDiskCacheEntry *)mBuffer; + diskEntry->Unswap(); // disk to memory + // Check if calculated size agrees with bytesRead + if (bytesRead < 0 || (uint32_t)bytesRead < diskEntry->Size()) + return nullptr; + + // Return the buffer containing the diskEntry structure + return diskEntry; +} + + +/** + * CreateDiskCacheEntry(nsCacheEntry * entry) + * + * Prepare an nsCacheEntry for writing to disk + */ +nsDiskCacheEntry * +nsDiskCacheMap::CreateDiskCacheEntry(nsDiskCacheBinding * binding, + uint32_t * aSize) +{ + nsCacheEntry * entry = binding->mCacheEntry; + if (!entry) return nullptr; + + // Store security info, if it is serializable + nsCOMPtr<nsISupports> infoObj = entry->SecurityInfo(); + nsCOMPtr<nsISerializable> serializable = do_QueryInterface(infoObj); + if (infoObj && !serializable) return nullptr; + if (serializable) { + nsCString info; + nsresult rv = NS_SerializeToString(serializable, info); + if (NS_FAILED(rv)) return nullptr; + rv = entry->SetMetaDataElement("security-info", info.get()); + if (NS_FAILED(rv)) return nullptr; + } + + uint32_t keySize = entry->Key()->Length() + 1; + uint32_t metaSize = entry->MetaDataSize(); + uint32_t size = sizeof(nsDiskCacheEntry) + keySize + metaSize; + + if (aSize) *aSize = size; + + nsresult rv = EnsureBuffer(size); + if (NS_FAILED(rv)) return nullptr; + + nsDiskCacheEntry *diskEntry = (nsDiskCacheEntry *)mBuffer; + diskEntry->mHeaderVersion = nsDiskCache::kCurrentVersion; + diskEntry->mMetaLocation = binding->mRecord.MetaLocation(); + diskEntry->mFetchCount = entry->FetchCount(); + diskEntry->mLastFetched = entry->LastFetched(); + diskEntry->mLastModified = entry->LastModified(); + diskEntry->mExpirationTime = entry->ExpirationTime(); + diskEntry->mDataSize = entry->DataSize(); + diskEntry->mKeySize = keySize; + diskEntry->mMetaDataSize = metaSize; + + memcpy(diskEntry->Key(), entry->Key()->get(), keySize); + + rv = entry->FlattenMetaData(diskEntry->MetaData(), metaSize); + if (NS_FAILED(rv)) return nullptr; + + return diskEntry; +} + + +nsresult +nsDiskCacheMap::WriteDiskCacheEntry(nsDiskCacheBinding * binding) +{ + CACHE_LOG_DEBUG(("CACHE: WriteDiskCacheEntry [%x]\n", + binding->mRecord.HashNumber())); + + nsresult rv = NS_OK; + uint32_t size; + nsDiskCacheEntry * diskEntry = CreateDiskCacheEntry(binding, &size); + if (!diskEntry) return NS_ERROR_UNEXPECTED; + + uint32_t fileIndex = CalculateFileIndex(size); + + // Deallocate old storage if necessary + if (binding->mRecord.MetaLocationInitialized()) { + // we have existing storage + + if ((binding->mRecord.MetaFile() == 0) && + (fileIndex == 0)) { // keeping the separate file + // just decrement total + DecrementTotalSize(binding->mRecord.MetaFileSize()); + NS_ASSERTION(binding->mRecord.MetaFileGeneration() == binding->mGeneration, + "generations out of sync"); + } else { + rv = DeleteStorage(&binding->mRecord, nsDiskCache::kMetaData); + NS_ENSURE_SUCCESS(rv, rv); + } + } + + binding->mRecord.SetEvictionRank(ULONG_MAX - SecondsFromPRTime(PR_Now())); + // write entry data to disk cache block file + diskEntry->Swap(); + + if (fileIndex != 0) { + while (1) { + uint32_t blockSize = GetBlockSizeForIndex(fileIndex); + uint32_t blocks = ((size - 1) / blockSize) + 1; + + int32_t startBlock; + rv = mBlockFile[fileIndex - 1].WriteBlocks(diskEntry, size, blocks, + &startBlock); + if (NS_SUCCEEDED(rv)) { + // update binding and cache map record + binding->mRecord.SetMetaBlocks(fileIndex, startBlock, blocks); + + rv = UpdateRecord(&binding->mRecord); + NS_ENSURE_SUCCESS(rv, rv); + + // XXX we should probably write out bucket ourselves + + IncrementTotalSize(blocks, blockSize); + break; + } + + if (fileIndex == kNumBlockFiles) { + fileIndex = 0; // write data to separate file + break; + } + + // try next block file + fileIndex++; + } + } + + if (fileIndex == 0) { + // Write entry data to separate file + uint32_t metaFileSizeK = ((size + 0x03FF) >> 10); // round up to nearest 1k + if (metaFileSizeK > kMaxDataSizeK) + metaFileSizeK = kMaxDataSizeK; + + binding->mRecord.SetMetaFileGeneration(binding->mGeneration); + binding->mRecord.SetMetaFileSize(metaFileSizeK); + rv = UpdateRecord(&binding->mRecord); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIFile> localFile; + rv = GetLocalFileForDiskCacheRecord(&binding->mRecord, + nsDiskCache::kMetaData, + true, + getter_AddRefs(localFile)); + NS_ENSURE_SUCCESS(rv, rv); + + // open the file + PRFileDesc * fd; + // open the file - restricted to user, the data could be confidential + rv = localFile->OpenNSPRFileDesc(PR_RDWR | PR_TRUNCATE | PR_CREATE_FILE, 00600, &fd); + NS_ENSURE_SUCCESS(rv, rv); + + // write the file + int32_t bytesWritten = PR_Write(fd, diskEntry, size); + + PRStatus err = PR_Close(fd); + if ((bytesWritten != (int32_t)size) || (err != PR_SUCCESS)) { + return NS_ERROR_UNEXPECTED; + } + + IncrementTotalSize(metaFileSizeK); + } + + return rv; +} + + +nsresult +nsDiskCacheMap::ReadDataCacheBlocks(nsDiskCacheBinding * binding, char * buffer, uint32_t size) +{ + CACHE_LOG_DEBUG(("CACHE: ReadDataCacheBlocks [%x size=%u]\n", + binding->mRecord.HashNumber(), size)); + + uint32_t fileIndex = binding->mRecord.DataFile(); + int32_t readSize = size; + + nsresult rv = mBlockFile[fileIndex - 1].ReadBlocks(buffer, + binding->mRecord.DataStartBlock(), + binding->mRecord.DataBlockCount(), + &readSize); + NS_ENSURE_SUCCESS(rv, rv); + if (readSize < (int32_t)size) { + rv = NS_ERROR_UNEXPECTED; + } + return rv; +} + + +nsresult +nsDiskCacheMap::WriteDataCacheBlocks(nsDiskCacheBinding * binding, char * buffer, uint32_t size) +{ + CACHE_LOG_DEBUG(("CACHE: WriteDataCacheBlocks [%x size=%u]\n", + binding->mRecord.HashNumber(), size)); + + nsresult rv = NS_OK; + + // determine block file & number of blocks + uint32_t fileIndex = CalculateFileIndex(size); + uint32_t blockCount = 0; + int32_t startBlock = 0; + + if (size > 0) { + // if fileIndex is 0, bad things happen below, which makes gcc 4.7 + // complain, but it's not supposed to happen. See bug 854105. + MOZ_ASSERT(fileIndex); + while (fileIndex) { + uint32_t blockSize = GetBlockSizeForIndex(fileIndex); + blockCount = ((size - 1) / blockSize) + 1; + + rv = mBlockFile[fileIndex - 1].WriteBlocks(buffer, size, blockCount, + &startBlock); + if (NS_SUCCEEDED(rv)) { + IncrementTotalSize(blockCount, blockSize); + break; + } + + if (fileIndex == kNumBlockFiles) + return rv; + + fileIndex++; + } + } + + // update binding and cache map record + binding->mRecord.SetDataBlocks(fileIndex, startBlock, blockCount); + if (!binding->mDoomed) { + rv = UpdateRecord(&binding->mRecord); + } + return rv; +} + + +nsresult +nsDiskCacheMap::DeleteStorage(nsDiskCacheRecord * record) +{ + nsresult rv1 = DeleteStorage(record, nsDiskCache::kData); + nsresult rv2 = DeleteStorage(record, nsDiskCache::kMetaData); + return NS_FAILED(rv1) ? rv1 : rv2; +} + + +nsresult +nsDiskCacheMap::DeleteStorage(nsDiskCacheRecord * record, bool metaData) +{ + CACHE_LOG_DEBUG(("CACHE: DeleteStorage [%x %u]\n", record->HashNumber(), + metaData)); + + nsresult rv = NS_ERROR_UNEXPECTED; + uint32_t fileIndex = metaData ? record->MetaFile() : record->DataFile(); + nsCOMPtr<nsIFile> file; + + if (fileIndex == 0) { + // delete the file + uint32_t sizeK = metaData ? record->MetaFileSize() : record->DataFileSize(); + // XXX if sizeK == USHRT_MAX, stat file for actual size + + rv = GetFileForDiskCacheRecord(record, metaData, false, getter_AddRefs(file)); + if (NS_SUCCEEDED(rv)) { + rv = file->Remove(false); // false == non-recursive + } + DecrementTotalSize(sizeK); + + } else if (fileIndex < (kNumBlockFiles + 1)) { + // deallocate blocks + uint32_t startBlock = metaData ? record->MetaStartBlock() : record->DataStartBlock(); + uint32_t blockCount = metaData ? record->MetaBlockCount() : record->DataBlockCount(); + + rv = mBlockFile[fileIndex - 1].DeallocateBlocks(startBlock, blockCount); + DecrementTotalSize(blockCount, GetBlockSizeForIndex(fileIndex)); + } + if (metaData) record->ClearMetaLocation(); + else record->ClearDataLocation(); + + return rv; +} + + +nsresult +nsDiskCacheMap::GetFileForDiskCacheRecord(nsDiskCacheRecord * record, + bool meta, + bool createPath, + nsIFile ** result) +{ + if (!mCacheDirectory) return NS_ERROR_NOT_AVAILABLE; + + nsCOMPtr<nsIFile> file; + nsresult rv = mCacheDirectory->Clone(getter_AddRefs(file)); + if (NS_FAILED(rv)) return rv; + + uint32_t hash = record->HashNumber(); + + // The file is stored under subdirectories according to the hash number: + // 0x01234567 -> 0/12/ + rv = file->AppendNative(nsPrintfCString("%X", hash >> 28)); + if (NS_FAILED(rv)) return rv; + rv = file->AppendNative(nsPrintfCString("%02X", (hash >> 20) & 0xFF)); + if (NS_FAILED(rv)) return rv; + + bool exists; + if (createPath && (NS_FAILED(file->Exists(&exists)) || !exists)) { + rv = file->Create(nsIFile::DIRECTORY_TYPE, 0700); + if (NS_FAILED(rv)) return rv; + } + + int16_t generation = record->Generation(); + char name[32]; + // Cut the beginning of the hash that was used in the path + ::SprintfLiteral(name, "%05X%c%02X", hash & 0xFFFFF, (meta ? 'm' : 'd'), + generation); + rv = file->AppendNative(nsDependentCString(name)); + if (NS_FAILED(rv)) return rv; + + NS_IF_ADDREF(*result = file); + return rv; +} + + +nsresult +nsDiskCacheMap::GetLocalFileForDiskCacheRecord(nsDiskCacheRecord * record, + bool meta, + bool createPath, + nsIFile ** result) +{ + nsCOMPtr<nsIFile> file; + nsresult rv = GetFileForDiskCacheRecord(record, + meta, + createPath, + getter_AddRefs(file)); + if (NS_FAILED(rv)) return rv; + + NS_IF_ADDREF(*result = file); + return rv; +} + + +nsresult +nsDiskCacheMap::GetBlockFileForIndex(uint32_t index, nsIFile ** result) +{ + if (!mCacheDirectory) return NS_ERROR_NOT_AVAILABLE; + + nsCOMPtr<nsIFile> file; + nsresult rv = mCacheDirectory->Clone(getter_AddRefs(file)); + if (NS_FAILED(rv)) return rv; + + char name[32]; + ::SprintfLiteral(name, "_CACHE_%03d_", index + 1); + rv = file->AppendNative(nsDependentCString(name)); + if (NS_FAILED(rv)) return rv; + + NS_IF_ADDREF(*result = file); + + return rv; +} + + +uint32_t +nsDiskCacheMap::CalculateFileIndex(uint32_t size) +{ + // We prefer to use block file with larger block if the wasted space would + // be the same. E.g. store entry with size of 3073 bytes in 1 4K-block + // instead of in 4 1K-blocks. + + if (size <= 3 * BLOCK_SIZE_FOR_INDEX(1)) return 1; + if (size <= 3 * BLOCK_SIZE_FOR_INDEX(2)) return 2; + if (size <= 4 * BLOCK_SIZE_FOR_INDEX(3)) return 3; + return 0; +} + +nsresult +nsDiskCacheMap::EnsureBuffer(uint32_t bufSize) +{ + if (mBufferSize < bufSize) { + char * buf = (char *)PR_REALLOC(mBuffer, bufSize); + if (!buf) { + mBufferSize = 0; + return NS_ERROR_OUT_OF_MEMORY; + } + mBuffer = buf; + mBufferSize = bufSize; + } + return NS_OK; +} + +void +nsDiskCacheMap::NotifyCapacityChange(uint32_t capacity) +{ + // Heuristic 1. average cache entry size is probably around 1KB + // Heuristic 2. we don't want more than 32MB reserved to store the record + // map in memory. + const int32_t RECORD_COUNT_LIMIT = 32 * 1024 * 1024 / sizeof(nsDiskCacheRecord); + int32_t maxRecordCount = std::min(int32_t(capacity), RECORD_COUNT_LIMIT); + if (mMaxRecordCount < maxRecordCount) { + // We can only grow + mMaxRecordCount = maxRecordCount; + } +} + +size_t +nsDiskCacheMap::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) +{ + size_t usage = aMallocSizeOf(mRecordArray); + + usage += aMallocSizeOf(mBuffer); + usage += aMallocSizeOf(mMapFD); + usage += aMallocSizeOf(mCleanFD); + usage += aMallocSizeOf(mCacheDirectory); + usage += aMallocSizeOf(mCleanCacheTimer); + + for (int i = 0; i < kNumBlockFiles; i++) { + usage += mBlockFile[i].SizeOfExcludingThis(aMallocSizeOf); + } + + return usage; +} + +nsresult +nsDiskCacheMap::InitCacheClean(nsIFile * cacheDirectory, + nsDiskCache::CorruptCacheInfo * corruptInfo) +{ + // The _CACHE_CLEAN_ file will be used in the future to determine + // if the cache is clean or not. + bool cacheCleanFileExists = false; + nsCOMPtr<nsIFile> cacheCleanFile; + nsresult rv = cacheDirectory->GetParent(getter_AddRefs(cacheCleanFile)); + if (NS_SUCCEEDED(rv)) { + rv = cacheCleanFile->AppendNative( + NS_LITERAL_CSTRING("_CACHE_CLEAN_")); + if (NS_SUCCEEDED(rv)) { + // Check if the file already exists, if it does, we will later read the + // value and report it to telemetry. + cacheCleanFile->Exists(&cacheCleanFileExists); + } + } + if (NS_FAILED(rv)) { + NS_WARNING("Could not build cache clean file path"); + *corruptInfo = nsDiskCache::kCacheCleanFilePathError; + return rv; + } + + // Make sure the _CACHE_CLEAN_ file exists + rv = cacheCleanFile->OpenNSPRFileDesc(PR_RDWR | PR_CREATE_FILE, + 00600, &mCleanFD); + if (NS_FAILED(rv)) { + NS_WARNING("Could not open cache clean file"); + *corruptInfo = nsDiskCache::kCacheCleanOpenFileError; + return rv; + } + + if (cacheCleanFileExists) { + char clean = '0'; + int32_t bytesRead = PR_Read(mCleanFD, &clean, 1); + if (bytesRead != 1) { + NS_WARNING("Could not read _CACHE_CLEAN_ file contents"); + } + } + + // Create a timer that will be used to validate the cache + // as long as an activity threshold was met + mCleanCacheTimer = do_CreateInstance("@mozilla.org/timer;1", &rv); + if (NS_SUCCEEDED(rv)) { + mCleanCacheTimer->SetTarget(nsCacheService::GlobalInstance()->mCacheIOThread); + rv = ResetCacheTimer(); + } + + if (NS_FAILED(rv)) { + NS_WARNING("Could not create cache clean timer"); + mCleanCacheTimer = nullptr; + *corruptInfo = nsDiskCache::kCacheCleanTimerError; + return rv; + } + + return NS_OK; +} + +nsresult +nsDiskCacheMap::WriteCacheClean(bool clean) +{ + nsCacheService::AssertOwnsLock(); + if (!mCleanFD) { + NS_WARNING("Cache clean file is not open!"); + return NS_ERROR_FAILURE; + } + + CACHE_LOG_DEBUG(("CACHE: WriteCacheClean: %d\n", clean? 1 : 0)); + // I'm using a simple '1' or '0' to denote cache clean + // since it can be edited easily by any text editor for testing. + char data = clean? '1' : '0'; + int32_t filePos = PR_Seek(mCleanFD, 0, PR_SEEK_SET); + if (filePos != 0) { + NS_WARNING("Could not seek in cache clean file!"); + return NS_ERROR_FAILURE; + } + int32_t bytesWritten = PR_Write(mCleanFD, &data, 1); + if (bytesWritten != 1) { + NS_WARNING("Could not write cache clean file!"); + return NS_ERROR_FAILURE; + } + PRStatus err = PR_Sync(mCleanFD); + if (err != PR_SUCCESS) { + NS_WARNING("Could not flush cache clean file!"); + } + + return NS_OK; +} + +nsresult +nsDiskCacheMap::InvalidateCache() +{ + nsCacheService::AssertOwnsLock(); + CACHE_LOG_DEBUG(("CACHE: InvalidateCache\n")); + nsresult rv; + + if (!mIsDirtyCacheFlushed) { + rv = WriteCacheClean(false); + if (NS_FAILED(rv)) { + return rv; + } + + mIsDirtyCacheFlushed = true; + } + + rv = ResetCacheTimer(); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +nsDiskCacheMap::ResetCacheTimer(int32_t timeout) +{ + mCleanCacheTimer->Cancel(); + nsresult rv = + mCleanCacheTimer->InitWithFuncCallback(RevalidateTimerCallback, + nullptr, timeout, + nsITimer::TYPE_ONE_SHOT); + NS_ENSURE_SUCCESS(rv, rv); + mLastInvalidateTime = PR_IntervalNow(); + + return rv; +} + +void +nsDiskCacheMap::RevalidateTimerCallback(nsITimer *aTimer, void *arg) +{ + nsCacheServiceAutoLock lock; + if (!nsCacheService::gService->mDiskDevice || + !nsCacheService::gService->mDiskDevice->Initialized()) { + return; + } + + nsDiskCacheMap *diskCacheMap = + &nsCacheService::gService->mDiskDevice->mCacheMap; + + // If we have less than kRevalidateCacheTimeout since the last timer was + // issued then another thread called InvalidateCache. This won't catch + // all cases where we wanted to cancel the timer, but under the lock it + // is always OK to revalidate as long as IsCacheInSafeState() returns + // true. We just want to avoid revalidating when we can to reduce IO + // and this check will do that. + uint32_t delta = + PR_IntervalToMilliseconds(PR_IntervalNow() - + diskCacheMap->mLastInvalidateTime) + + kRevalidateCacheTimeoutTolerance; + if (delta < kRevalidateCacheTimeout) { + diskCacheMap->ResetCacheTimer(); + return; + } + + nsresult rv = diskCacheMap->RevalidateCache(); + if (NS_FAILED(rv)) { + diskCacheMap->ResetCacheTimer(kRevalidateCacheErrorTimeout); + } +} + +bool +nsDiskCacheMap::IsCacheInSafeState() +{ + return nsCacheService::GlobalInstance()->IsDoomListEmpty(); +} + +nsresult +nsDiskCacheMap::RevalidateCache() +{ + CACHE_LOG_DEBUG(("CACHE: RevalidateCache\n")); + nsresult rv; + + if (!IsCacheInSafeState()) { + CACHE_LOG_DEBUG(("CACHE: Revalidation should not performed because " + "cache not in a safe state\n")); + // Normally we would return an error here, but there is a bug where + // the doom list sometimes gets an entry 'stuck' and doens't clear it + // until browser shutdown. So we allow revalidation for the time being + // to get proper telemetry data of how much the cache corruption plan + // would help. + } + + // If telemetry data shows it is worth it, we'll be flushing headers and + // records before flushing the clean cache file. + + // Write out the _CACHE_CLEAN_ file with '1' + rv = WriteCacheClean(true); + if (NS_FAILED(rv)) { + return rv; + } + + mIsDirtyCacheFlushed = false; + + return NS_OK; +} |