Add m-esr52 at 52.6.0

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);
+}