summaryrefslogtreecommitdiffstats
path: root/netwerk/cache/nsDiskCacheBlockFile.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'netwerk/cache/nsDiskCacheBlockFile.cpp')
-rw-r--r--netwerk/cache/nsDiskCacheBlockFile.cpp404
1 files changed, 404 insertions, 0 deletions
diff --git a/netwerk/cache/nsDiskCacheBlockFile.cpp b/netwerk/cache/nsDiskCacheBlockFile.cpp
new file mode 100644
index 000000000..6a1f4182f
--- /dev/null
+++ b/netwerk/cache/nsDiskCacheBlockFile.cpp
@@ -0,0 +1,404 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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 "nsDiskCache.h"
+#include "nsDiskCacheBlockFile.h"
+#include "mozilla/FileUtils.h"
+#include "mozilla/MemoryReporting.h"
+#include <algorithm>
+
+using namespace mozilla;
+
+/******************************************************************************
+ * nsDiskCacheBlockFile -
+ *****************************************************************************/
+
+/******************************************************************************
+ * Open
+ *****************************************************************************/
+nsresult
+nsDiskCacheBlockFile::Open(nsIFile * blockFile,
+ uint32_t blockSize,
+ uint32_t bitMapSize,
+ nsDiskCache::CorruptCacheInfo * corruptInfo)
+{
+ NS_ENSURE_ARG_POINTER(corruptInfo);
+ *corruptInfo = nsDiskCache::kUnexpectedError;
+
+ if (bitMapSize % 32) {
+ *corruptInfo = nsDiskCache::kInvalidArgPointer;
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ mBlockSize = blockSize;
+ mBitMapWords = bitMapSize / 32;
+ uint32_t bitMapBytes = mBitMapWords * 4;
+
+ // open the file - restricted to user, the data could be confidential
+ nsresult rv = blockFile->OpenNSPRFileDesc(PR_RDWR | PR_CREATE_FILE, 00600, &mFD);
+ if (NS_FAILED(rv)) {
+ *corruptInfo = nsDiskCache::kCouldNotCreateBlockFile;
+ CACHE_LOG_DEBUG(("CACHE: nsDiskCacheBlockFile::Open "
+ "[this=%p] unable to open or create file: %d",
+ this, rv));
+ return rv; // unable to open or create file
+ }
+
+ // allocate bit map buffer
+ mBitMap = new uint32_t[mBitMapWords];
+
+ // check if we just creating the file
+ mFileSize = PR_Available(mFD);
+ if (mFileSize < 0) {
+ // XXX an error occurred. We could call PR_GetError(), but how would that help?
+ *corruptInfo = nsDiskCache::kBlockFileSizeError;
+ rv = NS_ERROR_UNEXPECTED;
+ goto error_exit;
+ }
+ if (mFileSize == 0) {
+ // initialize bit map and write it
+ memset(mBitMap, 0, bitMapBytes);
+ if (!Write(0, mBitMap, bitMapBytes)) {
+ *corruptInfo = nsDiskCache::kBlockFileBitMapWriteError;
+ goto error_exit;
+ }
+
+ } else if ((uint32_t)mFileSize < bitMapBytes) {
+ *corruptInfo = nsDiskCache::kBlockFileSizeLessThanBitMap;
+ rv = NS_ERROR_UNEXPECTED; // XXX NS_ERROR_CACHE_INVALID;
+ goto error_exit;
+
+ } else {
+ // read the bit map
+ const int32_t bytesRead = PR_Read(mFD, mBitMap, bitMapBytes);
+ if ((bytesRead < 0) || ((uint32_t)bytesRead < bitMapBytes)) {
+ *corruptInfo = nsDiskCache::kBlockFileBitMapReadError;
+ rv = NS_ERROR_UNEXPECTED;
+ goto error_exit;
+ }
+#if defined(IS_LITTLE_ENDIAN)
+ // Swap from network format
+ for (unsigned int i = 0; i < mBitMapWords; ++i)
+ mBitMap[i] = ntohl(mBitMap[i]);
+#endif
+ // validate block file size
+ // Because not whole blocks are written, the size may be a
+ // little bit smaller than used blocks times blocksize,
+ // because the last block will generally not be 'whole'.
+ const uint32_t estimatedSize = CalcBlockFileSize();
+ if ((uint32_t)mFileSize + blockSize < estimatedSize) {
+ *corruptInfo = nsDiskCache::kBlockFileEstimatedSizeError;
+ rv = NS_ERROR_UNEXPECTED;
+ goto error_exit;
+ }
+ }
+ CACHE_LOG_DEBUG(("CACHE: nsDiskCacheBlockFile::Open [this=%p] succeeded",
+ this));
+ return NS_OK;
+
+error_exit:
+ CACHE_LOG_DEBUG(("CACHE: nsDiskCacheBlockFile::Open [this=%p] failed with "
+ "error %d", this, rv));
+ Close(false);
+ return rv;
+}
+
+
+/******************************************************************************
+ * Close
+ *****************************************************************************/
+nsresult
+nsDiskCacheBlockFile::Close(bool flush)
+{
+ nsresult rv = NS_OK;
+
+ if (mFD) {
+ if (flush)
+ rv = FlushBitMap();
+ PRStatus err = PR_Close(mFD);
+ if (NS_SUCCEEDED(rv) && (err != PR_SUCCESS))
+ rv = NS_ERROR_UNEXPECTED;
+ mFD = nullptr;
+ }
+
+ if (mBitMap) {
+ delete [] mBitMap;
+ mBitMap = nullptr;
+ }
+
+ return rv;
+}
+
+
+/******************************************************************************
+ * AllocateBlocks
+ *
+ * Allocates 1-4 blocks, using a first fit strategy,
+ * so that no group of blocks spans a quad block boundary.
+ *
+ * Returns block number of first block allocated or -1 on failure.
+ *
+ *****************************************************************************/
+int32_t
+nsDiskCacheBlockFile::AllocateBlocks(int32_t numBlocks)
+{
+ const int maxPos = 32 - numBlocks;
+ const uint32_t mask = (0x01 << numBlocks) - 1;
+ for (unsigned int i = 0; i < mBitMapWords; ++i) {
+ uint32_t mapWord = ~mBitMap[i]; // flip bits so free bits are 1
+ if (mapWord) { // At least one free bit
+ // Binary search for first free bit in word
+ int bit = 0;
+ if ((mapWord & 0x0FFFF) == 0) { bit |= 16; mapWord >>= 16; }
+ if ((mapWord & 0x000FF) == 0) { bit |= 8; mapWord >>= 8; }
+ if ((mapWord & 0x0000F) == 0) { bit |= 4; mapWord >>= 4; }
+ if ((mapWord & 0x00003) == 0) { bit |= 2; mapWord >>= 2; }
+ if ((mapWord & 0x00001) == 0) { bit |= 1; mapWord >>= 1; }
+ // Find first fit for mask
+ for (; bit <= maxPos; ++bit) {
+ // all bits selected by mask are 1, so free
+ if ((mask & mapWord) == mask) {
+ mBitMap[i] |= mask << bit;
+ mBitMapDirty = true;
+ return (int32_t)i * 32 + bit;
+ }
+ }
+ }
+ }
+
+ return -1;
+}
+
+
+/******************************************************************************
+ * DeallocateBlocks
+ *****************************************************************************/
+nsresult
+nsDiskCacheBlockFile::DeallocateBlocks( int32_t startBlock, int32_t numBlocks)
+{
+ if (!mFD) return NS_ERROR_NOT_AVAILABLE;
+
+ if ((startBlock < 0) || ((uint32_t)startBlock > mBitMapWords * 32 - 1) ||
+ (numBlocks < 1) || (numBlocks > 4))
+ return NS_ERROR_ILLEGAL_VALUE;
+
+ const int32_t startWord = startBlock >> 5; // Divide by 32
+ const uint32_t startBit = startBlock & 31; // Modulo by 32
+
+ // make sure requested deallocation doesn't span a word boundary
+ if (startBit + numBlocks > 32) return NS_ERROR_UNEXPECTED;
+ uint32_t mask = ((0x01 << numBlocks) - 1) << startBit;
+
+ // make sure requested deallocation is currently allocated
+ if ((mBitMap[startWord] & mask) != mask) return NS_ERROR_ABORT;
+
+ mBitMap[startWord] ^= mask; // flips the bits off;
+ mBitMapDirty = true;
+ // XXX rv = FlushBitMap(); // coherency vs. performance
+ return NS_OK;
+}
+
+
+/******************************************************************************
+ * WriteBlocks
+ *****************************************************************************/
+nsresult
+nsDiskCacheBlockFile::WriteBlocks( void * buffer,
+ uint32_t size,
+ int32_t numBlocks,
+ int32_t * startBlock)
+{
+ // presume buffer != nullptr and startBlock != nullptr
+ NS_ENSURE_TRUE(mFD, NS_ERROR_NOT_AVAILABLE);
+
+ // allocate some blocks in the cache block file
+ *startBlock = AllocateBlocks(numBlocks);
+ if (*startBlock < 0)
+ return NS_ERROR_NOT_AVAILABLE;
+
+ // seek to block position
+ int32_t blockPos = mBitMapWords * 4 + *startBlock * mBlockSize;
+
+ // write the blocks
+ return Write(blockPos, buffer, size) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+
+/******************************************************************************
+ * ReadBlocks
+ *****************************************************************************/
+nsresult
+nsDiskCacheBlockFile::ReadBlocks( void * buffer,
+ int32_t startBlock,
+ int32_t numBlocks,
+ int32_t * bytesRead)
+{
+ // presume buffer != nullptr and bytesRead != bytesRead
+
+ if (!mFD) return NS_ERROR_NOT_AVAILABLE;
+ nsresult rv = VerifyAllocation(startBlock, numBlocks);
+ if (NS_FAILED(rv)) return rv;
+
+ // seek to block position
+ int32_t blockPos = mBitMapWords * 4 + startBlock * mBlockSize;
+ int32_t filePos = PR_Seek(mFD, blockPos, PR_SEEK_SET);
+ if (filePos != blockPos) return NS_ERROR_UNEXPECTED;
+
+ // read the blocks
+ int32_t bytesToRead = *bytesRead;
+ if ((bytesToRead <= 0) || ((uint32_t)bytesToRead > mBlockSize * numBlocks)) {
+ bytesToRead = mBlockSize * numBlocks;
+ }
+ *bytesRead = PR_Read(mFD, buffer, bytesToRead);
+
+ CACHE_LOG_DEBUG(("CACHE: nsDiskCacheBlockFile::Read [this=%p] "
+ "returned %d / %d bytes", this, *bytesRead, bytesToRead));
+
+ return NS_OK;
+}
+
+
+/******************************************************************************
+ * FlushBitMap
+ *****************************************************************************/
+nsresult
+nsDiskCacheBlockFile::FlushBitMap()
+{
+ if (!mBitMapDirty) return NS_OK;
+
+#if defined(IS_LITTLE_ENDIAN)
+ uint32_t *bitmap = new uint32_t[mBitMapWords];
+ // Copy and swap to network format
+ uint32_t *p = bitmap;
+ for (unsigned int i = 0; i < mBitMapWords; ++i, ++p)
+ *p = htonl(mBitMap[i]);
+#else
+ uint32_t *bitmap = mBitMap;
+#endif
+
+ // write bitmap
+ bool written = Write(0, bitmap, mBitMapWords * 4);
+#if defined(IS_LITTLE_ENDIAN)
+ delete [] bitmap;
+#endif
+ if (!written)
+ return NS_ERROR_UNEXPECTED;
+
+ PRStatus err = PR_Sync(mFD);
+ if (err != PR_SUCCESS) return NS_ERROR_UNEXPECTED;
+
+ mBitMapDirty = false;
+ return NS_OK;
+}
+
+
+/******************************************************************************
+ * VerifyAllocation
+ *
+ * Return values:
+ * NS_OK if all bits are marked allocated
+ * NS_ERROR_ILLEGAL_VALUE if parameters don't obey constraints
+ * NS_ERROR_FAILURE if some or all the bits are marked unallocated
+ *
+ *****************************************************************************/
+nsresult
+nsDiskCacheBlockFile::VerifyAllocation( int32_t startBlock, int32_t numBlocks)
+{
+ if ((startBlock < 0) || ((uint32_t)startBlock > mBitMapWords * 32 - 1) ||
+ (numBlocks < 1) || (numBlocks > 4))
+ return NS_ERROR_ILLEGAL_VALUE;
+
+ const int32_t startWord = startBlock >> 5; // Divide by 32
+ const uint32_t startBit = startBlock & 31; // Modulo by 32
+
+ // make sure requested deallocation doesn't span a word boundary
+ if (startBit + numBlocks > 32) return NS_ERROR_ILLEGAL_VALUE;
+ uint32_t mask = ((0x01 << numBlocks) - 1) << startBit;
+
+ // check if all specified blocks are currently allocated
+ if ((mBitMap[startWord] & mask) != mask) return NS_ERROR_FAILURE;
+
+ return NS_OK;
+}
+
+
+/******************************************************************************
+ * CalcBlockFileSize
+ *
+ * Return size of the block file according to the bits set in mBitmap
+ *
+ *****************************************************************************/
+uint32_t
+nsDiskCacheBlockFile::CalcBlockFileSize()
+{
+ // search for last byte in mBitMap with allocated bits
+ uint32_t estimatedSize = mBitMapWords * 4;
+ int32_t i = mBitMapWords;
+ while (--i >= 0) {
+ if (mBitMap[i]) break;
+ }
+
+ if (i >= 0) {
+ // binary search to find last allocated bit in byte
+ uint32_t mapWord = mBitMap[i];
+ uint32_t lastBit = 31;
+ if ((mapWord & 0xFFFF0000) == 0) { lastBit ^= 16; mapWord <<= 16; }
+ if ((mapWord & 0xFF000000) == 0) { lastBit ^= 8; mapWord <<= 8; }
+ if ((mapWord & 0xF0000000) == 0) { lastBit ^= 4; mapWord <<= 4; }
+ if ((mapWord & 0xC0000000) == 0) { lastBit ^= 2; mapWord <<= 2; }
+ if ((mapWord & 0x80000000) == 0) { lastBit ^= 1; mapWord <<= 1; }
+ estimatedSize += (i * 32 + lastBit + 1) * mBlockSize;
+ }
+
+ return estimatedSize;
+}
+
+/******************************************************************************
+ * Write
+ *
+ * Wrapper around PR_Write that grows file in larger chunks to combat fragmentation
+ *
+ *****************************************************************************/
+bool
+nsDiskCacheBlockFile::Write(int32_t offset, const void *buf, int32_t amount)
+{
+ /* Grow the file to 4mb right away, then double it until the file grows to 20mb.
+ 20mb is a magic threshold because OSX stops autodefragging files bigger than that.
+ Beyond 20mb grow in 4mb chunks.
+ */
+ const int32_t upTo = offset + amount;
+ // Use a conservative definition of 20MB
+ const int32_t minPreallocate = 4*1024*1024;
+ const int32_t maxPreallocate = 20*1000*1000;
+ if (mFileSize < upTo) {
+ // maximal file size
+ const int32_t maxFileSize = mBitMapWords * 4 * (mBlockSize * 8 + 1);
+ if (upTo > maxPreallocate) {
+ // grow the file as a multiple of minPreallocate
+ mFileSize = ((upTo + minPreallocate - 1) / minPreallocate) * minPreallocate;
+ } else {
+ // Grow quickly between 1MB to 20MB
+ if (mFileSize)
+ while(mFileSize < upTo)
+ mFileSize *= 2;
+ mFileSize = clamped(mFileSize, minPreallocate, maxPreallocate);
+ }
+ mFileSize = std::min(mFileSize, maxFileSize);
+#if !defined(XP_MACOSX)
+ mozilla::fallocate(mFD, mFileSize);
+#endif
+ }
+ if (PR_Seek(mFD, offset, PR_SEEK_SET) != offset)
+ return false;
+ return PR_Write(mFD, buf, amount) == amount;
+}
+
+size_t
+nsDiskCacheBlockFile::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf)
+{
+ return aMallocSizeOf(mBitMap) + aMallocSizeOf(mFD);
+}