The Tor Browser: netwerk/cache2/CacheFileChunk.cpp@7e26c7da4463 (annotated)

netwerk/cache2/CacheFileChunk.cpp@7e26c7da4463 (annotated)

netwerk/cache2/CacheFileChunk.cpp

Wed, 31 Dec 2014 06:55:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:55:50 +0100
changeset 2: 7e26c7da4463
permissions: -rw-r--r--

Added tag UPSTREAM_283F7C6 for changeset ca08bd8f51b2

 /* 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 "CacheLog.h"
 #include "CacheFileChunk.h"
 #include "CacheFile.h"
 #include "nsThreadUtils.h"
 #include "nsAlgorithm.h"
 #include <algorithm>
 namespace mozilla {
 namespace net {
 #define kMinBufSize        512
 class NotifyUpdateListenerEvent : public nsRunnable {
 public:
   NotifyUpdateListenerEvent(CacheFileChunkListener *aCallback,
                             CacheFileChunk *aChunk)
     : mCallback(aCallback)
     , mChunk(aChunk)
   {
     LOG(("NotifyUpdateListenerEvent::NotifyUpdateListenerEvent() [this=%p]",
          this));
     MOZ_COUNT_CTOR(NotifyUpdateListenerEvent);
   }
   ~NotifyUpdateListenerEvent()
   {
     LOG(("NotifyUpdateListenerEvent::~NotifyUpdateListenerEvent() [this=%p]",
          this));
     MOZ_COUNT_DTOR(NotifyUpdateListenerEvent);
   }
   NS_IMETHOD Run()
   {
     LOG(("NotifyUpdateListenerEvent::Run() [this=%p]", this));
     mCallback->OnChunkUpdated(mChunk);
     return NS_OK;
   }
 protected:
   nsCOMPtr<CacheFileChunkListener> mCallback;
   nsRefPtr<CacheFileChunk>         mChunk;
 };
 class ValidityPair {
 public:
   ValidityPair(uint32_t aOffset, uint32_t aLen)
     : mOffset(aOffset), mLen(aLen)
   {}
   ValidityPair& operator=(const ValidityPair& aOther) {
     mOffset = aOther.mOffset;
     mLen = aOther.mLen;
     return *this;
   }
   bool Overlaps(const ValidityPair& aOther) const {
     if ((mOffset <= aOther.mOffset && mOffset + mLen >= aOther.mOffset) ||
         (aOther.mOffset <= mOffset && aOther.mOffset + mLen >= mOffset))
       return true;
     return false;
   }
   bool LessThan(const ValidityPair& aOther) const {
     if (mOffset < aOther.mOffset)
       return true;
     if (mOffset == aOther.mOffset && mLen < aOther.mLen)
       return true;
     return false;
   }
   void Merge(const ValidityPair& aOther) {
     MOZ_ASSERT(Overlaps(aOther));
     uint32_t offset = std::min(mOffset, aOther.mOffset);
     uint32_t end = std::max(mOffset + mLen, aOther.mOffset + aOther.mLen);
     mOffset = offset;
     mLen = end - offset;
   }
   uint32_t Offset() { return mOffset; }
   uint32_t Len()    { return mLen; }
 private:
   uint32_t mOffset;
   uint32_t mLen;
 };
 NS_IMPL_ADDREF(CacheFileChunk)
 NS_IMETHODIMP_(MozExternalRefCountType)
 CacheFileChunk::Release()
 {
   NS_PRECONDITION(0 != mRefCnt, "dup release");
   nsrefcnt count = --mRefCnt;
   NS_LOG_RELEASE(this, count, "CacheFileChunk");
   if (0 == count) {
     mRefCnt = 1;
     delete (this);
     return 0;
   }
   if (!mRemovingChunk && count == 1) {
     mFile->RemoveChunk(this);
   }
   return count;
 }
 NS_INTERFACE_MAP_BEGIN(CacheFileChunk)
   NS_INTERFACE_MAP_ENTRY(mozilla::net::CacheFileIOListener)
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END_THREADSAFE
 CacheFileChunk::CacheFileChunk(CacheFile *aFile, uint32_t aIndex)
   : CacheMemoryConsumer(aFile->mOpenAsMemoryOnly ? MEMORY_ONLY : DONT_REPORT)
   , mIndex(aIndex)
   , mState(INITIAL)
   , mStatus(NS_OK)
   , mIsDirty(false)
   , mRemovingChunk(false)
   , mDataSize(0)
   , mBuf(nullptr)
   , mBufSize(0)
   , mRWBuf(nullptr)
   , mRWBufSize(0)
   , mReadHash(0)
   , mFile(aFile)
 {
   LOG(("CacheFileChunk::CacheFileChunk() [this=%p]", this));
   MOZ_COUNT_CTOR(CacheFileChunk);
 }
 CacheFileChunk::~CacheFileChunk()
 {
   LOG(("CacheFileChunk::~CacheFileChunk() [this=%p]", this));
   MOZ_COUNT_DTOR(CacheFileChunk);
   if (mBuf) {
     free(mBuf);
     mBuf = nullptr;
     mBufSize = 0;
   }
   if (mRWBuf) {
     free(mRWBuf);
     mRWBuf = nullptr;
     mRWBufSize = 0;
   }
 }
 void
 CacheFileChunk::InitNew(CacheFileChunkListener *aCallback)
 {
   mFile->AssertOwnsLock();
   LOG(("CacheFileChunk::InitNew() [this=%p, listener=%p]", this, aCallback));
   MOZ_ASSERT(mState == INITIAL);
   MOZ_ASSERT(!mBuf);
   MOZ_ASSERT(!mRWBuf);
   mBuf = static_cast<char *>(moz_xmalloc(kMinBufSize));
   mBufSize = kMinBufSize;
   mDataSize = 0;
   mState = READY;
   mIsDirty = true;
   DoMemoryReport(MemorySize());
 }
 nsresult
 CacheFileChunk::Read(CacheFileHandle *aHandle, uint32_t aLen,
                      CacheHash::Hash16_t aHash,
                      CacheFileChunkListener *aCallback)
 {
   mFile->AssertOwnsLock();
   LOG(("CacheFileChunk::Read() [this=%p, handle=%p, len=%d, listener=%p]",
        this, aHandle, aLen, aCallback));
   MOZ_ASSERT(mState == INITIAL);
   MOZ_ASSERT(!mBuf);
   MOZ_ASSERT(!mRWBuf);
   MOZ_ASSERT(aLen);
   nsresult rv;
   mRWBuf = static_cast<char *>(moz_xmalloc(aLen));
   mRWBufSize = aLen;
   DoMemoryReport(MemorySize());
   rv = CacheFileIOManager::Read(aHandle, mIndex * kChunkSize, mRWBuf, aLen,
                                 true, this);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     rv = mIndex ? NS_ERROR_FILE_CORRUPTED : NS_ERROR_FILE_NOT_FOUND;
     SetError(rv);
   } else {
     mState = READING;
     mListener = aCallback;
     mDataSize = aLen;
     mReadHash = aHash;
   }
   return rv;
 }
 nsresult
 CacheFileChunk::Write(CacheFileHandle *aHandle,
                       CacheFileChunkListener *aCallback)
 {
   mFile->AssertOwnsLock();
   LOG(("CacheFileChunk::Write() [this=%p, handle=%p, listener=%p]",
        this, aHandle, aCallback));
   MOZ_ASSERT(mState == READY);
   MOZ_ASSERT(!mRWBuf);
   MOZ_ASSERT(mBuf);
   MOZ_ASSERT(mDataSize); // Don't write chunk when it is empty
   nsresult rv;
   mRWBuf = mBuf;
   mRWBufSize = mBufSize;
   mBuf = nullptr;
   mBufSize = 0;
   rv = CacheFileIOManager::Write(aHandle, mIndex * kChunkSize, mRWBuf,
                                  mDataSize, false, this);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     SetError(rv);
   } else {
     mState = WRITING;
     mListener = aCallback;
     mIsDirty = false;
   }
   return rv;
 }
 void
 CacheFileChunk::WaitForUpdate(CacheFileChunkListener *aCallback)
 {
   mFile->AssertOwnsLock();
   LOG(("CacheFileChunk::WaitForUpdate() [this=%p, listener=%p]",
        this, aCallback));
   MOZ_ASSERT(mFile->mOutput);
   MOZ_ASSERT(IsReady());
 #ifdef DEBUG
   for (uint32_t i = 0 ; i < mUpdateListeners.Length() ; i++) {
     MOZ_ASSERT(mUpdateListeners[i]->mCallback != aCallback);
   }
 #endif
   ChunkListenerItem *item = new ChunkListenerItem();
   item->mTarget = NS_GetCurrentThread();
   item->mCallback = aCallback;
   mUpdateListeners.AppendElement(item);
 }
 nsresult
 CacheFileChunk::CancelWait(CacheFileChunkListener *aCallback)
 {
   mFile->AssertOwnsLock();
   LOG(("CacheFileChunk::CancelWait() [this=%p, listener=%p]", this, aCallback));
   MOZ_ASSERT(IsReady());
   uint32_t i;
   for (i = 0 ; i < mUpdateListeners.Length() ; i++) {
     ChunkListenerItem *item = mUpdateListeners[i];
     if (item->mCallback == aCallback) {
       mUpdateListeners.RemoveElementAt(i);
       delete item;
       break;
     }
   }
 #ifdef DEBUG
   for ( ; i < mUpdateListeners.Length() ; i++) {
     MOZ_ASSERT(mUpdateListeners[i]->mCallback != aCallback);
   }
 #endif
   return NS_OK;
 }
 nsresult
 CacheFileChunk::NotifyUpdateListeners()
 {
   mFile->AssertOwnsLock();
   LOG(("CacheFileChunk::NotifyUpdateListeners() [this=%p]", this));
   MOZ_ASSERT(IsReady());
   nsresult rv, rv2;
   rv = NS_OK;
   for (uint32_t i = 0 ; i < mUpdateListeners.Length() ; i++) {
     ChunkListenerItem *item = mUpdateListeners[i];
     LOG(("CacheFileChunk::NotifyUpdateListeners() - Notifying listener %p "
          "[this=%p]", item->mCallback.get(), this));
     nsRefPtr<NotifyUpdateListenerEvent> ev;
     ev = new NotifyUpdateListenerEvent(item->mCallback, this);
     rv2 = item->mTarget->Dispatch(ev, NS_DISPATCH_NORMAL);
     if (NS_FAILED(rv2) && NS_SUCCEEDED(rv))
       rv = rv2;
     delete item;
   }
   mUpdateListeners.Clear();
   return rv;
 }
 uint32_t
 CacheFileChunk::Index()
 {
   return mIndex;
 }
 CacheHash::Hash16_t
 CacheFileChunk::Hash()
 {
   mFile->AssertOwnsLock();
   MOZ_ASSERT(mBuf);
   MOZ_ASSERT(!mListener);
   MOZ_ASSERT(IsReady());
   return CacheHash::Hash16(BufForReading(), mDataSize);
 }
 uint32_t
 CacheFileChunk::DataSize()
 {
   mFile->AssertOwnsLock();
   return mDataSize;
 }
 void
 CacheFileChunk::UpdateDataSize(uint32_t aOffset, uint32_t aLen, bool aEOF)
 {
   mFile->AssertOwnsLock();
   MOZ_ASSERT(!aEOF, "Implement me! What to do with opened streams?");
   MOZ_ASSERT(aOffset <= mDataSize);
   // UpdateDataSize() is called only when we've written some data to the chunk
   // and we never write data anymore once some error occurs.
   MOZ_ASSERT(mState != ERROR);
   LOG(("CacheFileChunk::UpdateDataSize() [this=%p, offset=%d, len=%d, EOF=%d]",
        this, aOffset, aLen, aEOF));
   mIsDirty = true;
   int64_t fileSize = kChunkSize * mIndex + aOffset + aLen;
   bool notify = false;
   if (fileSize > mFile->mDataSize)
     mFile->mDataSize = fileSize;
   if (aOffset + aLen > mDataSize) {
     mDataSize = aOffset + aLen;
     notify = true;
   }
   if (mState == READY || mState == WRITING) {
     MOZ_ASSERT(mValidityMap.Length() == 0);
     if (notify)
       NotifyUpdateListeners();
     return;
   }
   // We're still waiting for data from the disk. This chunk cannot be used by
   // input stream, so there must be no update listener. We also need to keep
   // track of where the data is written so that we can correctly merge the new
   // data with the old one.
   MOZ_ASSERT(mUpdateListeners.Length() == 0);
   MOZ_ASSERT(mState == READING);
   ValidityPair pair(aOffset, aLen);
   if (mValidityMap.Length() == 0) {
     mValidityMap.AppendElement(pair);
     return;
   }
   // Find out where to place this pair into the map, it can overlap with
   // one preceding pair and all subsequent pairs.
   uint32_t pos = 0;
   for (pos = mValidityMap.Length() ; pos > 0 ; pos--) {
     if (mValidityMap[pos-1].LessThan(pair)) {
       if (mValidityMap[pos-1].Overlaps(pair)) {
         // Merge with the preceding pair
         mValidityMap[pos-1].Merge(pair);
         pos--; // Point to the updated pair
       }
       else {
         if (pos == mValidityMap.Length())
           mValidityMap.AppendElement(pair);
         else
           mValidityMap.InsertElementAt(pos, pair);
       }
       break;
     }
   }
   if (!pos)
     mValidityMap.InsertElementAt(0, pair);
   // Now pos points to merged or inserted pair, check whether it overlaps with
   // subsequent pairs.
   while (pos + 1 < mValidityMap.Length()) {
     if (mValidityMap[pos].Overlaps(mValidityMap[pos + 1])) {
       mValidityMap[pos].Merge(mValidityMap[pos + 1]);
       mValidityMap.RemoveElementAt(pos + 1);
     }
     else {
       break;
     }
   }
 }
 nsresult
 CacheFileChunk::OnFileOpened(CacheFileHandle *aHandle, nsresult aResult)
 {
   MOZ_CRASH("CacheFileChunk::OnFileOpened should not be called!");
   return NS_ERROR_UNEXPECTED;
 }
 nsresult
 CacheFileChunk::OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
                               nsresult aResult)
 {
   LOG(("CacheFileChunk::OnDataWritten() [this=%p, handle=%p, result=0x%08x]",
        this, aHandle, aResult));
   nsCOMPtr<CacheFileChunkListener> listener;
   {
     CacheFileAutoLock lock(mFile);
     MOZ_ASSERT(mState == WRITING);
     MOZ_ASSERT(mListener);
     if (NS_WARN_IF(NS_FAILED(aResult))) {
       SetError(aResult);
     } else {
       mState = READY;
     }
     if (!mBuf) {
       mBuf = mRWBuf;
       mBufSize = mRWBufSize;
     } else {
       free(mRWBuf);
     }
     mRWBuf = nullptr;
     mRWBufSize = 0;
     DoMemoryReport(MemorySize());
     mListener.swap(listener);
   }
   listener->OnChunkWritten(aResult, this);
   return NS_OK;
 }
 nsresult
 CacheFileChunk::OnDataRead(CacheFileHandle *aHandle, char *aBuf,
                            nsresult aResult)
 {
   LOG(("CacheFileChunk::OnDataRead() [this=%p, handle=%p, result=0x%08x]",
        this, aHandle, aResult));
   nsCOMPtr<CacheFileChunkListener> listener;
   {
     CacheFileAutoLock lock(mFile);
     MOZ_ASSERT(mState == READING);
     MOZ_ASSERT(mListener);
     if (NS_SUCCEEDED(aResult)) {
       CacheHash::Hash16_t hash = CacheHash::Hash16(mRWBuf, mRWBufSize);
       if (hash != mReadHash) {
         LOG(("CacheFileChunk::OnDataRead() - Hash mismatch! Hash of the data is"
              " %hx, hash in metadata is %hx. [this=%p, idx=%d]",
              hash, mReadHash, this, mIndex));
         aResult = NS_ERROR_FILE_CORRUPTED;
       }
       else {
         if (!mBuf) {
           // Just swap the buffers if we don't have mBuf yet
           MOZ_ASSERT(mDataSize == mRWBufSize);
           mBuf = mRWBuf;
           mBufSize = mRWBufSize;
           mRWBuf = nullptr;
           mRWBufSize = 0;
         } else {
           // Merge data with write buffer
           if (mRWBufSize < mBufSize) {
             mRWBuf = static_cast<char *>(moz_xrealloc(mRWBuf, mBufSize));
             mRWBufSize = mBufSize;
           }
           for (uint32_t i = 0 ; i < mValidityMap.Length() ; i++) {
             memcpy(mRWBuf + mValidityMap[i].Offset(),
                    mBuf + mValidityMap[i].Offset(), mValidityMap[i].Len());
           }
           free(mBuf);
           mBuf = mRWBuf;
           mBufSize = mRWBufSize;
           mRWBuf = nullptr;
           mRWBufSize = 0;
           DoMemoryReport(MemorySize());
         }
       }
     }
     if (NS_FAILED(aResult)) {
       aResult = mIndex ? NS_ERROR_FILE_CORRUPTED : NS_ERROR_FILE_NOT_FOUND;
       SetError(aResult);
       mDataSize = 0;
     } else {
       mState = READY;
     }
     mListener.swap(listener);
   }
   listener->OnChunkRead(aResult, this);
   return NS_OK;
 }
 nsresult
 CacheFileChunk::OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult)
 {
   MOZ_CRASH("CacheFileChunk::OnFileDoomed should not be called!");
   return NS_ERROR_UNEXPECTED;
 }
 nsresult
 CacheFileChunk::OnEOFSet(CacheFileHandle *aHandle, nsresult aResult)
 {
   MOZ_CRASH("CacheFileChunk::OnEOFSet should not be called!");
   return NS_ERROR_UNEXPECTED;
 }
 nsresult
 CacheFileChunk::OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult)
 {
   MOZ_CRASH("CacheFileChunk::OnFileRenamed should not be called!");
   return NS_ERROR_UNEXPECTED;
 }
 bool
 CacheFileChunk::IsReady() const
 {
   mFile->AssertOwnsLock();
   return (NS_SUCCEEDED(mStatus) && (mState == READY || mState == WRITING));
 }
 bool
 CacheFileChunk::IsDirty() const
 {
   mFile->AssertOwnsLock();
   return mIsDirty;
 }
 nsresult
 CacheFileChunk::GetStatus()
 {
   mFile->AssertOwnsLock();
   return mStatus;
 }
 void
 CacheFileChunk::SetError(nsresult aStatus)
 {
   if (NS_SUCCEEDED(mStatus)) {
     MOZ_ASSERT(mState != ERROR);
     mStatus = aStatus;
     mState = ERROR;
   } else {
     MOZ_ASSERT(mState == ERROR);
   }
 }
 char *
 CacheFileChunk::BufForWriting() const
 {
   mFile->AssertOwnsLock();
   MOZ_ASSERT(mBuf); // Writer should always first call EnsureBufSize()
   MOZ_ASSERT((mState == READY && !mRWBuf) ||
              (mState == WRITING && mRWBuf) ||
              (mState == READING && mRWBuf));
   return mBuf;
 }
 const char *
 CacheFileChunk::BufForReading() const
 {
   mFile->AssertOwnsLock();
   MOZ_ASSERT((mState == READY && mBuf && !mRWBuf) ||
              (mState == WRITING && mRWBuf));
   return mBuf ? mBuf : mRWBuf;
 }
 void
 CacheFileChunk::EnsureBufSize(uint32_t aBufSize)
 {
   mFile->AssertOwnsLock();
   // EnsureBufSize() is called only when we want to write some data to the chunk
   // and we never write data anymore once some error occurs.
   MOZ_ASSERT(mState != ERROR);
   if (mBufSize >= aBufSize)
     return;
   bool copy = false;
   if (!mBuf && mState == WRITING) {
     // We need to duplicate the data that is being written on the background
     // thread, so make sure that all the data fits into the new buffer.
     copy = true;
     if (mRWBufSize > aBufSize)
       aBufSize = mRWBufSize;
   }
   // find smallest power of 2 greater than or equal to aBufSize
   aBufSize--;
   aBufSize |= aBufSize >> 1;
   aBufSize |= aBufSize >> 2;
   aBufSize |= aBufSize >> 4;
   aBufSize |= aBufSize >> 8;
   aBufSize |= aBufSize >> 16;
   aBufSize++;
   const uint32_t minBufSize = kMinBufSize;
   const uint32_t maxBufSize = kChunkSize;
   aBufSize = clamped(aBufSize, minBufSize, maxBufSize);
   mBuf = static_cast<char *>(moz_xrealloc(mBuf, aBufSize));
   mBufSize = aBufSize;
   if (copy)
     memcpy(mBuf, mRWBuf, mRWBufSize);
   DoMemoryReport(MemorySize());
 }
 // Memory reporting
 size_t
 CacheFileChunk::SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const
 {
   size_t n = 0;
   n += mallocSizeOf(mBuf);
   n += mallocSizeOf(mRWBuf);
   n += mValidityMap.SizeOfExcludingThis(mallocSizeOf);
   return n;
 }
 size_t
 CacheFileChunk::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
 {
   return mallocSizeOf(this) + SizeOfExcludingThis(mallocSizeOf);
 }
 } // net
 } // mozilla

The Tor Browser / annotate

netwerk/cache2/CacheFileChunk.cpp@7e26c7da4463 (annotated)

netwerk/cache2/CacheFileChunk.cpp