diff options
Diffstat (limited to 'netwerk/cache/nsDiskCacheBlockFile.cpp')
| -rw-r--r-- | netwerk/cache/nsDiskCacheBlockFile.cpp | 404 |
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); +} |