Macintosh-SW
/
tenfourfox
mirror of https://github.com/classilla/tenfourfox.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
tenfourfox/netwerk/cache/nsDiskCacheBlockFile.cpp

405 lines
14 KiB
C++
Raw Permalink Blame History

/* -*- 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);
}
Reference in New Issue View Git Blame Copy Permalink