netwerk/cache2/CacheFileChunk.h

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #ifndef CacheFileChunk__h__
   6 #define CacheFileChunk__h__
   7
   8 #include "CacheFileIOManager.h"
   9 #include "CacheStorageService.h"
  10 #include "CacheHashUtils.h"
  11 #include "CacheFileUtils.h"
  12 #include "mozilla/Mutex.h"
  13 #include "mozilla/UniquePtr.h"
  14
  15 namespace mozilla {
  16 namespace net {
  17
  18 constexpr int32_t kChunkSize = 256 * 1024;
  19 constexpr size_t kEmptyChunkHash = 0x1826;
  20
  21 class CacheFileChunk;
  22 class CacheFile;
  23
  24 class CacheFileChunkBuffer {
  25  public:
  26   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(CacheFileChunkBuffer)
  27
  28   explicit CacheFileChunkBuffer(CacheFileChunk* aChunk);
  29
  30   nsresult EnsureBufSize(uint32_t aBufSize);
  31   void CopyFrom(CacheFileChunkBuffer* aOther);
  32   nsresult FillInvalidRanges(CacheFileChunkBuffer* aOther,
  33                              CacheFileUtils::ValidityMap* aMap);
  34   size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
  35
  36   char* Buf() const { return mBuf; }
  37   void SetDataSize(uint32_t aDataSize);
  38   uint32_t DataSize() const { return mDataSize; }
  39   uint32_t ReadHandlesCount() const { return mReadHandlesCount; }
  40   bool WriteHandleExists() const { return mWriteHandleExists; }
  41
  42  private:
  43   friend class CacheFileChunkHandle;
  44   friend class CacheFileChunkReadHandle;
  45   friend class CacheFileChunkWriteHandle;
  46
  47   ~CacheFileChunkBuffer();
  48
  49   void AssertOwnsLock() const;
  50
  51   void RemoveReadHandle();
  52   void RemoveWriteHandle();
  53
  54   // We keep a weak reference to the chunk to not create a reference cycle. The
  55   // buffer is referenced only by chunk and handles. Handles are always
  56   // destroyed before the chunk so it is guaranteed that mChunk is a valid
  57   // pointer for the whole buffer's lifetime.
  58   CacheFileChunk* mChunk;
  59   char* mBuf;
  60   uint32_t mBufSize;
  61   uint32_t mDataSize;
  62   uint32_t mReadHandlesCount;
  63   bool mWriteHandleExists;
  64 };
  65
  66 class CacheFileChunkHandle {
  67  public:
  68   uint32_t DataSize();
  69   uint32_t Offset();
  70
  71  protected:
  72   RefPtr<CacheFileChunkBuffer> mBuf;
  73 };
  74
  75 class CacheFileChunkReadHandle : public CacheFileChunkHandle {
  76  public:
  77   explicit CacheFileChunkReadHandle(CacheFileChunkBuffer* aBuf);
  78   ~CacheFileChunkReadHandle();
  79
  80   const char* Buf();
  81 };
  82
  83 class CacheFileChunkWriteHandle : public CacheFileChunkHandle {
  84  public:
  85   explicit CacheFileChunkWriteHandle(CacheFileChunkBuffer* aBuf);
  86   ~CacheFileChunkWriteHandle();
  87
  88   char* Buf();
  89   void UpdateDataSize(uint32_t aOffset, uint32_t aLen);
  90 };
  91
  92 #define CACHEFILECHUNKLISTENER_IID                   \
  93   { /* baf16149-2ab5-499c-a9c2-5904eb95c288 */       \
  94     0xbaf16149, 0x2ab5, 0x499c, {                    \
  95       0xa9, 0xc2, 0x59, 0x04, 0xeb, 0x95, 0xc2, 0x88 \
  96     }                                                \
  97   }
  98
  99 class CacheFileChunkListener : public nsISupports {
 100  public:
 101   NS_DECLARE_STATIC_IID_ACCESSOR(CACHEFILECHUNKLISTENER_IID)
 102
 103   NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk* aChunk) = 0;
 104   NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk* aChunk) = 0;
 105   NS_IMETHOD OnChunkAvailable(nsresult aResult, uint32_t aChunkIdx,
 106                               CacheFileChunk* aChunk) = 0;
 107   NS_IMETHOD OnChunkUpdated(CacheFileChunk* aChunk) = 0;
 108 };
 109
 110 NS_DEFINE_STATIC_IID_ACCESSOR(CacheFileChunkListener,
 111                               CACHEFILECHUNKLISTENER_IID)
 112
 113 class ChunkListenerItem {
 114  public:
 115   MOZ_COUNTED_DEFAULT_CTOR(ChunkListenerItem)
 116   MOZ_COUNTED_DTOR(ChunkListenerItem)
 117
 118   nsCOMPtr<nsIEventTarget> mTarget;
 119   nsCOMPtr<CacheFileChunkListener> mCallback;
 120 };
 121
 122 class ChunkListeners {
 123  public:
 124   MOZ_COUNTED_DEFAULT_CTOR(ChunkListeners)
 125   MOZ_COUNTED_DTOR(ChunkListeners)
 126
 127   nsTArray<ChunkListenerItem*> mItems;
 128 };
 129
 130 class CacheFileChunk final : public CacheFileIOListener,
 131                              public CacheMemoryConsumer {
 132  public:
 133   NS_DECL_THREADSAFE_ISUPPORTS
 134   bool DispatchRelease();
 135
 136   CacheFileChunk(CacheFile* aFile, uint32_t aIndex, bool aInitByWriter);
 137
 138   void InitNew();
 139   nsresult Read(CacheFileHandle* aHandle, uint32_t aLen,
 140                 CacheHash::Hash16_t aHash, CacheFileChunkListener* aCallback);
 141   nsresult Write(CacheFileHandle* aHandle, CacheFileChunkListener* aCallback);
 142   void WaitForUpdate(CacheFileChunkListener* aCallback);
 143   void CancelWait(CacheFileChunkListener* aCallback);
 144   nsresult NotifyUpdateListeners();
 145
 146   uint32_t Index() const;
 147   CacheHash::Hash16_t Hash() const;
 148   uint32_t DataSize() const;
 149
 150   NS_IMETHOD OnFileOpened(CacheFileHandle* aHandle, nsresult aResult) override;
 151   NS_IMETHOD OnDataWritten(CacheFileHandle* aHandle, const char* aBuf,
 152                            nsresult aResult) override;
 153   NS_IMETHOD OnDataRead(CacheFileHandle* aHandle, char* aBuf,
 154                         nsresult aResult) override;
 155   NS_IMETHOD OnFileDoomed(CacheFileHandle* aHandle, nsresult aResult) override;
 156   NS_IMETHOD OnEOFSet(CacheFileHandle* aHandle, nsresult aResult) override;
 157   NS_IMETHOD OnFileRenamed(CacheFileHandle* aHandle, nsresult aResult) override;
 158   virtual bool IsKilled() override;
 159
 160   bool IsReady() const;
 161   bool IsDirty() const;
 162
 163   nsresult GetStatus();
 164   void SetError(nsresult aStatus);
 165
 166   CacheFileChunkReadHandle GetReadHandle();
 167   CacheFileChunkWriteHandle GetWriteHandle(uint32_t aEnsuredBufSize);
 168
 169   // Memory reporting
 170   size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
 171   size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
 172
 173  private:
 174   friend class CacheFileChunkBuffer;
 175   friend class CacheFileChunkWriteHandle;
 176   friend class CacheFileInputStream;
 177   friend class CacheFileOutputStream;
 178   friend class CacheFile;
 179
 180   virtual ~CacheFileChunk();
 181
 182   void AssertOwnsLock() const;
 183
 184   void UpdateDataSize(uint32_t aOffset, uint32_t aLen);
 185   void Truncate(uint32_t aOffset);
 186
 187   bool CanAllocate(uint32_t aSize) const;
 188   void BuffersAllocationChanged(uint32_t aFreed, uint32_t aAllocated);
 189
 190   mozilla::Atomic<uint32_t, ReleaseAcquire>& ChunksMemoryUsage() const;
 191
 192   enum EState { INITIAL = 0, READING = 1, WRITING = 2, READY = 3 };
 193
 194   uint32_t mIndex;
 195   EState mState;
 196   nsresult mStatus;
 197
 198   Atomic<bool> mActiveChunk;  // Is true iff the chunk is in CacheFile::mChunks.
 199                               // Adding/removing chunk to/from mChunks as well
 200                               // as changing this member happens under the
 201                               // CacheFile's lock.
 202   bool mIsDirty : 1;
 203   bool mDiscardedChunk : 1;
 204
 205   uint32_t mBuffersSize;
 206   bool const mLimitAllocation : 1;  // Whether this chunk respects limit for
 207                                     // disk chunks memory usage.
 208   bool const mIsPriority : 1;
 209
 210   // Buffer containing the chunk data. Multiple read handles can access the same
 211   // buffer. When write handle is created and some read handle exists a new copy
 212   // of the buffer is created. This prevents invalidating the buffer when
 213   // CacheFileInputStream::ReadSegments calls the handler outside the lock.
 214   RefPtr<CacheFileChunkBuffer> mBuf;
 215
 216   // We need to keep pointers of the old buffers for memory reporting.
 217   nsTArray<RefPtr<CacheFileChunkBuffer>> mOldBufs;
 218
 219   // Read handle that is used during writing the chunk to the disk.
 220   UniquePtr<CacheFileChunkReadHandle> mWritingStateHandle;
 221
 222   // Buffer that is used to read the chunk from the disk. It is allowed to write
 223   // a new data to chunk while we wait for the data from the disk. In this case
 224   // this buffer is merged with mBuf in OnDataRead().
 225   RefPtr<CacheFileChunkBuffer> mReadingStateBuf;
 226   CacheHash::Hash16_t mExpectedHash;
 227
 228   RefPtr<CacheFile> mFile;  // is null if chunk is cached to
 229                             // prevent reference cycles
 230   nsCOMPtr<CacheFileChunkListener> mListener;
 231   nsTArray<ChunkListenerItem*> mUpdateListeners;
 232   CacheFileUtils::ValidityMap mValidityMap;
 233 };
 234
 235 }  // namespace net
 236 }  // namespace mozilla
 237
 238 #endif