The Tor Browser / file revision

 /* 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